﻿using System;
using System.Collections.Generic;
using System.Text;

using RaisingStudio.Data.Common;
using RaisingStudio.Data.Expressions;
using RaisingStudio.Data.Common.Factories;
using RaisingStudio.Data.Providers.Adapters;
using System.IO;

namespace RaisingStudio.Data.Providers
{
    public partial class DataProvider : RaisingStudio.Data.Common.DataContextBase, RaisingStudio.Data.Common.IDataProvider
    {
        #region Common Properties
        private Dictionary<System.Type, RaisingStudio.Data.Providers.Adapters.DataTableAdapter> dataTableAdapters = new Dictionary<System.Type, DataTableAdapter>();
        /// <summary>
        /// datatable adapter dictionary.
        /// </summary>
        public Dictionary<System.Type, RaisingStudio.Data.Providers.Adapters.DataTableAdapter> DataTableAdapters
        {
            get
            {
                return dataTableAdapters;
            }
        }

        private bool cacheDataTableAdapters = true;
        /// <summary>
        /// 缓存datatable DataAdapter.
        /// </summary>
        public bool CacheDataTableAdapters
        {
            get
            {
                return cacheDataTableAdapters;
            }
            set
            {
                cacheDataTableAdapters = value;
            }
        }

        private Dictionary<System.Type, RaisingStudio.Data.Providers.Adapters.DataObjectAdapter> dataObjectAdapters = new Dictionary<System.Type, DataObjectAdapter>();
        /// <summary>
        /// data object adapter dictionary.
        /// </summary>
        public Dictionary<System.Type, RaisingStudio.Data.Providers.Adapters.DataObjectAdapter> DataObjectAdapters
        {
            get
            {
                return dataObjectAdapters;
            }
        }

        private bool cacheDataObjectAdapters = true;
        /// <summary>
        /// 缓存data object DataAdapter.
        /// </summary>
        public bool CacheDataObjectAdapters
        {
            get
            {
                return cacheDataObjectAdapters;
            }
            set
            {
                cacheDataObjectAdapters = value;
            }
        }

        private Dictionary<System.Type, RaisingStudio.Data.Providers.Adapters.DataItemAdapter> dataItemAdapters = new Dictionary<System.Type, DataItemAdapter>();
        /// <summary>
        /// DataItem adapter dictionary.
        /// </summary>
        public Dictionary<System.Type, RaisingStudio.Data.Providers.Adapters.DataItemAdapter> DataItemAdapters
        {
            get
            {
                return dataItemAdapters;
            }
        }

        private bool cacheDataItemAdapters = true;
        /// <summary>
        /// 缓存DataItem DataAdapter.
        /// </summary>
        public bool CacheDataItemAdapters
        {
            get
            {
                return cacheDataItemAdapters;
            }
            set
            {
                cacheDataItemAdapters = value;
            }
        }

        private Dictionary<System.Type, RaisingStudio.Data.Providers.Adapters.DataSetAdapter> dataSetAdapters = new Dictionary<System.Type, DataSetAdapter>();
        /// <summary>
        /// dataset adapter dictionary.
        /// </summary>
        public Dictionary<System.Type, RaisingStudio.Data.Providers.Adapters.DataSetAdapter> DataSetAdapters
        {
            get
            {
                return dataSetAdapters;
            }
        }

        private bool cacheDataSetAdapters = true;
        /// <summary>
        /// 缓存dataset DataAdapter.
        /// </summary>
        public bool CacheDataSetAdapters
        {
            get
            {
                return cacheDataSetAdapters;
            }
            set
            {
                cacheDataSetAdapters = value;
            }
        }
        #endregion

#if (PocketPC || Smartphone || WindowsCE)
        private bool _useDynamicProxy = false;
#else
        private bool _useDynamicProxy = true;
#endif
        public bool UseDynamicProxy
        {
            get { return _useDynamicProxy; }
            set { _useDynamicProxy = value; }
        }

        private bool _cacheDefalutCommand = true;

        public bool CacheDefalutCommand
        {
            get { return _cacheDefalutCommand; }
            set { _cacheDefalutCommand = value; }
        }

        #region Common Methods
        /// <summary>
        /// Create datatable DataAdapter.
        /// </summary>
        /// <param name="dataTableType">datatable Type.</param>
        /// <returns>datatable DataAdapter.</returns>
        protected virtual RaisingStudio.Data.Providers.Adapters.DataTableAdapter CreateDataTableAdapter(System.Type dataTableType)
        {
            return new RaisingStudio.Data.Providers.Adapters.DataTableAdapter(dataTableType, this.TransactionManager, base.DatabaseType, base.ProviderName, this.LogManager);
        }

        /// <summary>
        /// Gets datatable DataAdapter.
        /// </summary>
        /// <param name="dataTableType">datatable Type.</param>
        /// <returns>datatable DataAdapter.</returns>
        public virtual DataTableAdapter GetDataTableAdapter(System.Type dataTableType)
        {
            if (cacheDataTableAdapters)
            {
                if (!dataTableAdapters.ContainsKey(dataTableType))
                {
                    DataTableAdapter dataTableAdapter = CreateDataTableAdapter(dataTableType);
                    dataTableAdapters.Add(dataTableType, dataTableAdapter);
                    return dataTableAdapter;
                }
                else
                {
                    return dataTableAdapters[dataTableType];
                }
            }
            else
            {
                return CreateDataTableAdapter(dataTableType);
            }
        }

        /// <summary>
        /// Create data object DataAdapter.
        /// </summary>
        /// <param name="dataObjectType">data Type of data object.</param>
        /// <returns>data object DataAdapter.</returns>
        protected virtual RaisingStudio.Data.Providers.Adapters.DataObjectAdapter CreateDataObjectAdapter(System.Type dataObjectType)
        {
            RaisingStudio.Data.Providers.Adapters.DataObjectAdapter dataObjectAdapter = new RaisingStudio.Data.Providers.Adapters.DataObjectAdapter(dataObjectType, this.TransactionManager, base.DatabaseType, base.ProviderName, this.LogManager);
            dataObjectAdapter.UseDynamicProxy = this.UseDynamicProxy;
            return dataObjectAdapter;
        }

        /// <summary>
        /// Gets data object DataAdapter.
        /// </summary>
        /// <param name="dataObjectType">data Type of data object.</param>
        /// <returns>data object DataAdapter.</returns>
        public virtual DataObjectAdapter GetDataObjectAdapter(System.Type dataObjectType)
        {
            if (cacheDataObjectAdapters)
            {
                if (!dataObjectAdapters.ContainsKey(dataObjectType))
                {
                    DataObjectAdapter dataObjectAdapter = CreateDataObjectAdapter(dataObjectType);
                    dataObjectAdapters.Add(dataObjectType, dataObjectAdapter);
                    return dataObjectAdapter;
                }
                else
                {
                    return dataObjectAdapters[dataObjectType];
                }
            }
            else
            {
                return CreateDataObjectAdapter(dataObjectType);
            }
        }

        /// <summary>
        /// Create DataItem DataAdapter.
        /// </summary>
        /// <param name="dataItemType">DataItem Type.</param>
        /// <returns>DataItem DataAdapter.</returns>
        protected virtual RaisingStudio.Data.Providers.Adapters.DataItemAdapter CreateDataItemAdapter(System.Type dataItemType)
        {
            return new RaisingStudio.Data.Providers.Adapters.DataItemAdapter(dataItemType, this.TransactionManager, base.DatabaseType, base.ProviderName, this.LogManager);
        }

        /// <summary>
        /// Gets DataItem DataAdapter.
        /// </summary>
        /// <param name="dataItemType">DataItem Type.</param>
        /// <returns>DataItem DataAdapter.</returns>
        public virtual DataItemAdapter GetDataItemAdapter(System.Type dataItemType)
        {
            if (cacheDataItemAdapters)
            {
                if (!dataItemAdapters.ContainsKey(dataItemType))
                {
                    DataItemAdapter dataItemAdapter = CreateDataItemAdapter(dataItemType);
                    dataItemAdapters.Add(dataItemType, dataItemAdapter);
                    return dataItemAdapter;
                }
                else
                {
                    return dataItemAdapters[dataItemType];
                }
            }
            else
            {
                return CreateDataItemAdapter(dataItemType);
            }
        }

        /// <summary>
        /// Create dataset DataAdapter.
        /// </summary>
        /// <param name="dataSetType">dataset Type.</param>
        /// <returns>dataset DataAdapter.</returns>
        protected virtual RaisingStudio.Data.Providers.Adapters.DataSetAdapter CreateDataSetAdapter(System.Type dataSetType)
        {
            return new RaisingStudio.Data.Providers.Adapters.DataSetAdapter(dataSetType, this.TransactionManager, base.DatabaseType, base.ProviderName, this.LogManager);
        }

        /// <summary>
        /// Gets dataset DataAdapter.
        /// </summary>
        /// <param name="dataSetType">dataset Type.</param>
        /// <returns>dataset DataAdapter.</returns>
        public virtual DataSetAdapter GetDataSetAdapter(System.Type dataSetType)
        {
            if (cacheDataSetAdapters)
            {
                if (!dataSetAdapters.ContainsKey(dataSetType))
                {
                    DataSetAdapter dataSetAdapter = CreateDataSetAdapter(dataSetType);
                    dataSetAdapters.Add(dataSetType, dataSetAdapter);
                    return dataSetAdapter;
                }
                else
                {
                    return dataSetAdapters[dataSetType];
                }
            }
            else
            {
                return CreateDataSetAdapter(dataSetType);
            }
        }
        #endregion
        
        #region Constructor
        /// <summary>
        /// Constructor
        /// </summary>
        public DataProvider()
        {
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="connection">database connection.</param>
        public DataProvider(System.Data.IDbConnection connection)
            : base(connection)
        {
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="transactionManager">database transaction manager.</param>
        public DataProvider(TransactionManager transactionManager)
            : base(transactionManager)
        {
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="connectionName">the name of connection.</param>
        public DataProvider(string connectionName)
            : base(connectionName)
        {
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="databaseType">database type.</param>
        /// <param name="connectionString">connection string.</param>
        public DataProvider(DatabaseType databaseType, string connectionString)
            : base(databaseType, connectionString)
        {
        }

        public DataProvider(string providerName, string connectionString)
            : base(providerName, connectionString)
        {
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="transactionManager">database transaction manager.</param>
        public DataProvider(TransactionManager transactionManager, LogManager logManager)
            : base(transactionManager, logManager)
        {
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="transactionManager">database transaction manager.</param>
        public DataProvider(TransactionManager transactionManager, LogManager logManager, DatabaseType databaseType, string providerName)
            : base(transactionManager, logManager, databaseType, providerName)
        {
        }
        #endregion

        #region DataTable Functions 
        public int Delete(System.Type type, string transactionID)
        {
            return GetDataTableAdapter(type).Delete(transactionID);
        }

        public int Delete(System.Type type)
        {
            return GetDataTableAdapter(type).Delete();
        }

        public int Delete(System.Type type, string[] columnNames, object[] originalValues)
        {
            return GetDataTableAdapter(type).Delete(columnNames, originalValues);
        }

        public int Delete(System.Type type, object[] primaryKeys)
        {
            return GetDataTableAdapter(type).Delete(primaryKeys);
        }

        public int Delete(System.Type type, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).Delete(conditionCommand);
        }

        public int Delete(System.Type type, System.Collections.Generic.Dictionary<string, object> originalValues)
        {
            return GetDataTableAdapter(type).Delete(originalValues);
        }

        public int Delete(System.Type type, string[] columnNames, object[] originalValues, string transactionID)
        {
            return GetDataTableAdapter(type).Delete(columnNames, originalValues, transactionID);
        }

        public int Delete(System.Type type, object[] primaryKeys, string transactionID)
        {
            return GetDataTableAdapter(type).Delete(primaryKeys, transactionID);
        }

        public int Delete(System.Type type, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).Delete(conditionCommand, transactionID);
        }

        public int Delete(System.Type type, System.Collections.Generic.Dictionary<string, object> originalValues, string transactionID)
        {
            return GetDataTableAdapter(type).Delete(originalValues, transactionID);
        }

        public System.Data.DataTable ExecuteDataTable(System.Type type, CommonCommand selectCommand)
        {
            return GetDataTableAdapter(type).ExecuteDataTable(selectCommand);
        }

        public System.Data.DataTable ExecuteDataTable(Type type, CommonCommand selectCommand, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).ExecuteDataTable(selectCommand, startRecord, maxRecords);
        }

        public System.Data.DataTable ExecuteDataTable(System.Type type, CommonCommand selectCommand, string transactionID)
        {
            return GetDataTableAdapter(type).ExecuteDataTable(selectCommand, transactionID);
        }

        public int ExecuteDataTableNonQueryCommand(System.Type type, CommonCommand commonCommand, string transactionID)
        {
            return GetDataTableAdapter(type).ExecuteNonQueryCommand(commonCommand, transactionID);
        }

        public int ExecuteDataTableNonQueryCommand(System.Type type, CommonCommand commonCommand)
        {
            return GetDataTableAdapter(type).ExecuteNonQueryCommand(commonCommand);
        }

        public System.Data.IDataReader ExecuteDataTableReaderCommand(System.Type type, CommonCommand commonCommand, string transactionID)
        {
            return GetDataTableAdapter(type).ExecuteReaderCommand(commonCommand, transactionID);
        }

        public System.Data.IDataReader ExecuteDataTableReaderCommand(System.Type type, CommonCommand commonCommand)
        {
            return GetDataTableAdapter(type).ExecuteReaderCommand(commonCommand);
        }

        public object ExecuteDataTableScalarCommand(System.Type type, CommonCommand commonCommand)
        {
            return GetDataTableAdapter(type).ExecuteScalarCommand(commonCommand);
        }

        public object ExecuteDataTableScalarCommand(System.Type type, CommonCommand commonCommand, string transactionID)
        {
            return GetDataTableAdapter(type).ExecuteScalarCommand(commonCommand, transactionID);
        }

        public bool Exists(System.Type type, object[] primaryKeys, string transactionID)
        {
            return GetDataTableAdapter(type).Exists(primaryKeys, transactionID);
        }

        public bool Exists(System.Type type, object[] primaryKeys)
        {
            return GetDataTableAdapter(type).Exists(primaryKeys);
        }

        public int Fill(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return Fill(dataTable.GetType(), dataTable, columnNames, conditionCommand, startRecord, maxRecords);
        }

        public int Fill(System.Data.DataTable dataTable, int startRecord, int maxRecords, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, startRecord, maxRecords, transactionID);
        }

        public int Fill(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public int Fill(System.Data.DataTable dataTable, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public int Fill(System.Data.DataTable dataTable, string[] columnNames, int startRecord, int maxRecords, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, columnNames, startRecord, maxRecords, transactionID);
        }

        public int Fill(System.Data.DataTable dataTable, string[] columnNames, int startRecord, int maxRecords)
        {
            return Fill(dataTable.GetType(), dataTable, columnNames, startRecord, maxRecords);
        }

        public int Fill(System.Data.DataTable dataTable, int startRecord, int maxRecords)
        {
            return Fill(dataTable.GetType(), dataTable, startRecord, maxRecords);
        }

        public int Fill(System.Data.DataTable dataTable, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return Fill(dataTable.GetType(), dataTable, conditionCommand, startRecord, maxRecords);
        }

        public int Fill(System.Data.DataTable dataTable, object[] primaryKeys, string[] columnNames)
        {
            return Fill(dataTable.GetType(), dataTable, primaryKeys, columnNames);
        }

        public int Fill(System.Data.DataTable dataTable, object[] primaryKeys)
        {
            return Fill(dataTable.GetType(), dataTable, primaryKeys);
        }

        public int Fill(System.Data.DataTable dataTable, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, transactionID);
        }

        public int Fill(System.Data.DataTable dataTable, string[] columnNames, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, columnNames, transactionID);
        }

        public int Fill(System.Data.DataTable dataTable, CommonCommand conditionCommand, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, conditionCommand, transactionID);
        }

        public int Fill(System.Data.DataTable dataTable, string[] columnNames)
        {
            return Fill(dataTable.GetType(), dataTable, columnNames);
        }

        public int Fill(System.Data.DataTable dataTable)
        {
            return Fill(dataTable.GetType(), dataTable);
        }

        public int Fill(System.Data.DataTable dataTable, CommonCommand conditionCommand)
        {
            return Fill(dataTable.GetType(), dataTable, conditionCommand);
        }

        public int Fill(System.Data.DataTable dataTable, object[] primaryKeys, string[] columnNames, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, primaryKeys, columnNames, transactionID);
        }

        public int Fill(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand)
        {
            return Fill(dataTable.GetType(), dataTable, columnNames, conditionCommand);
        }

        public int Fill(System.Data.DataTable dataTable, object[] primaryKeys, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, primaryKeys, transactionID);
        }

        public int Fill(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, columnNames, conditionCommand, transactionID);
        }

        public int FillDataTable(System.Data.DataTable dataTable, CommonCommand selectCommand)
        {
            return FillDataTable(dataTable.GetType(), dataTable, selectCommand);
        }

        public int FillDataTable(System.Data.DataTable dataTable, CommonCommand selectCommand, string transactionID)
        {
            return FillDataTable(dataTable.GetType(), dataTable, selectCommand, transactionID);
        }

        public int FillView(System.Data.DataTable dataTable, CommonCommand conditionCommand, string transactionID)
        {
            return FillView(dataTable.GetType(), dataTable, conditionCommand, transactionID);
        }

        public int FillView(System.Data.DataTable dataTable, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return FillView(dataTable.GetType(), dataTable, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public int FillView(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return FillView(dataTable.GetType(), dataTable, columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public int FillView(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return FillView(dataTable.GetType(), dataTable, columnNames, conditionCommand, transactionID);
        }

        public int FillView(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand)
        {
            return FillView(dataTable.GetType(), dataTable, columnNames, conditionCommand);
        }

        public int FillView(System.Data.DataTable dataTable, CommonCommand conditionCommand)
        {
            return FillView(dataTable.GetType(), dataTable, conditionCommand);
        }

        public int FillView(System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return FillView(dataTable.GetType(), dataTable, columnNames, conditionCommand, startRecord, maxRecords);
        }

        public int FillView(System.Data.DataTable dataTable, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return FillView(dataTable.GetType(), dataTable, conditionCommand, startRecord, maxRecords);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnNames, conditionCommand, startRecord, maxRecords);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, startRecord, maxRecords, transactionID);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, string[] columnNames, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnNames, startRecord, maxRecords, transactionID);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, string[] columnNames, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnNames, startRecord, maxRecords);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).Fill(dataTable, startRecord, maxRecords);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).Fill(dataTable, conditionCommand, startRecord, maxRecords);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, object[] primaryKeys, string[] columnNames)
        {
            return GetDataTableAdapter(type).Fill(dataTable, primaryKeys, columnNames);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, object[] primaryKeys)
        {
            return GetDataTableAdapter(type).Fill(dataTable, primaryKeys);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, transactionID);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, string[] columnNames, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnNames, transactionID);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, conditionCommand, transactionID);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, string[] columnNames)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnNames);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable)
        {
            return GetDataTableAdapter(type).Fill(dataTable);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).Fill(dataTable, conditionCommand);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, object[] primaryKeys, string[] columnNames, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, primaryKeys, columnNames, transactionID);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnNames, conditionCommand);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, object[] primaryKeys, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, primaryKeys, transactionID);
        }

        public int Fill(System.Type type, System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnNames, conditionCommand, transactionID);
        }

        public int FillDataTable(System.Type type, System.Data.DataTable dataTable, CommonCommand selectCommand)
        {
            return GetDataTableAdapter(type).FillDataTable(dataTable, selectCommand);
        }

        public int FillDataTable(System.Type type, System.Data.DataTable dataTable, CommonCommand selectCommand, string transactionID)
        {
            return GetDataTableAdapter(type).FillDataTable(dataTable, selectCommand, transactionID);
        }

        public int FillView(System.Type type, System.Data.DataTable dataTable, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).FillView(dataTable, conditionCommand, transactionID);
        }

        public int FillView(System.Type type, System.Data.DataTable dataTable, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).FillView(dataTable, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public int FillView(System.Type type, System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).FillView(dataTable, columnNames, conditionCommand, transactionID);
        }

        public int FillView(System.Type type, System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).FillView(dataTable, columnNames, conditionCommand, transactionID);
        }

        public int FillView(System.Type type, System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).FillView(dataTable, columnNames, conditionCommand);
        }

        public int FillView(System.Type type, System.Data.DataTable dataTable, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).FillView(dataTable, conditionCommand);
        }

        public int FillView(System.Type type, System.Data.DataTable dataTable, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).FillView(dataTable, columnNames, conditionCommand, startRecord, maxRecords);
        }

        public int FillView(System.Type type, System.Data.DataTable dataTable, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).FillView(dataTable, conditionCommand, startRecord, maxRecords);
        }

        public object GetAvgData(System.Type type, string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).GetAvgData(columnName, conditionCommand, transactionID);
        }

        public object GetAvgData(System.Type type, string columnName, string transactionID)
        {
            return GetDataTableAdapter(type).GetAvgData(columnName, transactionID);
        }

        public object GetAvgData(System.Type type, string columnName, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).GetAvgData(columnName, conditionCommand);
        }

        public object GetAvgData(System.Type type, string columnName)
        {
            return GetDataTableAdapter(type).GetAvgData(columnName);
        }

        public object GetMaxData(System.Type type, string columnName, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).GetMaxData(columnName, conditionCommand);
        }

        public object GetMaxData(System.Type type, string columnName)
        {
            return GetDataTableAdapter(type).GetMaxData(columnName);
        }

        public object GetMaxData(System.Type type, string columnName, string transactionID)
        {
            return GetDataTableAdapter(type).GetMaxData(columnName, transactionID);
        }

        public object GetMaxData(System.Type type, string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).GetMaxData(columnName, conditionCommand, transactionID);
        }

        public object GetMinData(System.Type type, string columnName, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).GetMinData(columnName, conditionCommand);
        }

        public object GetMinData(System.Type type, string columnName, string transactionID)
        {
            return GetDataTableAdapter(type).GetMinData(columnName, transactionID);
        }

        public object GetMinData(System.Type type, string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).GetMinData(columnName, conditionCommand, transactionID);
        }

        public object GetMinData(System.Type type, string columnName)
        {
            return GetDataTableAdapter(type).GetMinData(columnName);
        }

        public object GetSumData(System.Type type, string columnName, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).GetSumData(columnName, conditionCommand);
        }

        public object GetSumData(System.Type type, string columnName)
        {
            return GetDataTableAdapter(type).GetSumData(columnName);
        }

        public object GetSumData(System.Type type, string columnName, string transactionID)
        {
            return GetDataTableAdapter(type).GetSumData(columnName, transactionID);
        }

        public object GetSumData(System.Type type, string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).GetSumData(columnName, conditionCommand, transactionID);
        }

        public int GetDataCount(System.Type type, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).GetDataCount(conditionCommand);
        }

        public int GetDataCount(System.Type type, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).GetDataCount(conditionCommand, transactionID);
        }

        public int GetDataCount(System.Type type, string transactionID)
        {
            return GetDataTableAdapter(type).GetDataCount(transactionID);
        }

        public int GetDataCount(System.Type type)
        {
            return GetDataTableAdapter(type).GetDataCount();
        }

        public System.Data.DataTable GetDataTable(System.Type type, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(transactionID);
        }

        public System.Data.DataTable GetDataTable(System.Type type, object[] primaryKeys, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(primaryKeys, transactionID);
        }

        public System.Data.DataTable GetDataTable(System.Type type, object[] primaryKeys, string[] columnNames, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(primaryKeys, columnNames, transactionID);
        }

        public System.Data.DataTable GetDataTable(System.Type type, string[] columnNames, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).GetData(columnNames, startRecord, maxRecords);
        }

        public System.Data.DataTable GetDataTable(System.Type type, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).GetData(startRecord, maxRecords);
        }

        public System.Data.DataTable GetDataTable(System.Type type, string[] columnNames, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(columnNames, transactionID);
        }

        public System.Data.DataTable GetDataTable(System.Type type, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).GetData(conditionCommand, startRecord, maxRecords);
        }

        public System.Data.DataTable GetDataTable(System.Type type)
        {
            return GetDataTableAdapter(type).GetData();
        }

        public System.Data.DataTable GetDataTable(System.Type type, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(conditionCommand, transactionID);
        }

        public System.Data.DataTable GetDataTable(System.Type type, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).GetData(columnNames, conditionCommand, startRecord, maxRecords);
        }

        public System.Data.DataTable GetDataTable(System.Type type, string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(columnNames, conditionCommand, transactionID);
        }

        public System.Data.DataTable GetDataTable(System.Type type, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).GetData(conditionCommand);
        }

        public System.Data.DataTable GetDataTable(System.Type type, string[] columnNames)
        {
            return GetDataTableAdapter(type).GetData(columnNames);
        }

        public System.Data.DataTable GetDataTable(System.Type type, string[] columnNames, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).GetData(columnNames, conditionCommand);
        }

        public System.Data.DataTable GetDataTable(System.Type type, object[] primaryKeys, string[] columnNames)
        {
            return GetDataTableAdapter(type).GetData(primaryKeys, columnNames);
        }

        public System.Data.DataTable GetDataTable(System.Type type, object[] primaryKeys)
        {
            return GetDataTableAdapter(type).GetData(primaryKeys);
        }

        public System.Data.DataTable GetDataTable(System.Type type, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Data.DataTable GetDataTable(System.Type type, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Data.DataTable GetDataTable(System.Type type, string[] columnNames, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(columnNames, startRecord, maxRecords, transactionID);
        }

        public System.Data.DataTable GetDataTable(System.Type type, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(startRecord, maxRecords, transactionID);
        }

        public object GetViewAvgData(System.Type type, string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewAvgData(columnName, conditionCommand, transactionID);
        }

        public object GetViewAvgData(System.Type type, string columnName, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).GetViewAvgData(columnName, conditionCommand);
        }

        public object GetViewMaxData(System.Type type, string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewMaxData(columnName, conditionCommand, transactionID);
        }

        public object GetViewMaxData(System.Type type, string columnName, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).GetViewMaxData(columnName, conditionCommand);
        }

        public object GetViewMinData(System.Type type, string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewMinData(columnName, conditionCommand, transactionID);
        }

        public object GetViewMinData(System.Type type, string columnName, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).GetViewMinData(columnName, conditionCommand);
        }

        public object GetViewSumData(System.Type type, string columnName, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewSumData(columnName, conditionCommand, transactionID);
        }

        public object GetViewSumData(System.Type type, string columnName, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).GetViewSumData(columnName, conditionCommand);
        }

        public int GetViewDataCount(System.Type type, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewDataCount(conditionCommand, transactionID);
        }

        public int GetViewDataCount(System.Type type, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).GetViewDataCount(conditionCommand);
        }

        public System.Data.DataTable GetViewData(System.Type type, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewData(columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Data.DataTable GetViewData(System.Type type, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewData(conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Data.DataTable GetViewData(System.Type type, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewData(conditionCommand, transactionID);
        }

        public System.Data.DataTable GetViewData(System.Type type, string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewData(columnNames, conditionCommand, transactionID);
        }

        public System.Data.DataTable GetViewData(System.Type type, string[] columnNames, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).GetViewData(columnNames, conditionCommand);
        }

        public System.Data.DataTable GetViewData(System.Type type, CommonCommand conditionCommand)
        {
            return GetDataTableAdapter(type).GetViewData(conditionCommand);
        }

        public System.Data.DataTable GetViewData(System.Type type, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).GetViewData(conditionCommand, startRecord, maxRecords);
        }

        public System.Data.DataTable GetViewData(System.Type type, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).GetViewData(columnNames, conditionCommand, startRecord, maxRecords);
        }

        public int Insert(System.Type type, object[] values)
        {
            return GetDataTableAdapter(type).Insert(values);
        }

        public int Insert(System.Type type, string[] columnNames, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Insert(columnNames, values, transactionID);
        }

        public int Insert(System.Type type, System.Collections.Generic.Dictionary<string, object> values, string transactionID)
        {
            return GetDataTableAdapter(type).Insert(values, transactionID);
        }

        public int Insert(System.Type type, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Insert(values, transactionID);
        }

        public int Insert(System.Type type, string[] columnNames, object[] values)
        {
            return GetDataTableAdapter(type).Insert(columnNames, values);
        }

        public int Insert(System.Type type, System.Collections.Generic.Dictionary<string, object> values)
        {
            return GetDataTableAdapter(type).Insert(values);
        }

        public int Save(System.Type type, object[] values)
        {
            return GetDataTableAdapter(type).Save(values);
        }

        public int Save(System.Type type, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Save(values, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, string[] columnNames, UpdateBehavior updateBehavior, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnNames, updateBehavior, transactionID);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataTable, checkConcurrency, updateBehavior, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, string[] columnNames, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnNames, checkConcurrency, updateBehavior, transactionID);
        }

        public int Update(System.Type type, CommonCommand conditionCommand, object[] values)
        {
            return GetDataTableAdapter(type).Update(conditionCommand, values);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, string[] columnNames, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnNames, checkConcurrency, updateBehavior, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRows, checkConcurrency, updateBehavior, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, UpdateBehavior updateBehavior, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRows, updateBehavior, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow dataRow, bool checkConcurrency, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRow, checkConcurrency, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, string[] columnNames, bool checkConcurrency, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnNames, checkConcurrency, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, bool checkConcurrency, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRows, checkConcurrency, transactionID);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, string[] columnNames, UpdateBehavior updateBehavior, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnNames, updateBehavior, transactionID);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, UpdateBehavior updateBehavior, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataTable, updateBehavior, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow dataRow, string[] columnNames, bool checkConcurrency, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRow, columnNames, checkConcurrency, transactionID);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, string[] columnNames)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnNames);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable)
        {
            return GetDataTableAdapter(type).Update(dataTable);
        }

        public int Update(System.Type type, System.Data.DataRow dataRow, string[] columnNames)
        {
            return GetDataTableAdapter(type).Update(dataRow, columnNames);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows)
        {
            return GetDataTableAdapter(type).Update(dataRows);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, string[] columnNames)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnNames);
        }

        public int Update(System.Type type, System.Data.DataRow dataRow)
        {
            return GetDataTableAdapter(type).Update(dataRow);
        }

        public int Update(System.Type type, object[] values)
        {
            return GetDataTableAdapter(type).Update(values);
        }

        public int Update(System.Type type, object[] primaryKeys, System.Collections.Generic.Dictionary<string, object> values)
        {
            return GetDataTableAdapter(type).Update(primaryKeys, values);
        }

        public int Update(System.Type type, string[] columnNames, object[] originalValues, object[] values)
        {
            return GetDataTableAdapter(type).Update(columnNames, originalValues, values);
        }

        public int Update(System.Type type, System.Collections.Generic.Dictionary<string, object> originalValues, System.Collections.Generic.Dictionary<string, object> values)
        {
            return GetDataTableAdapter(type).Update(originalValues, values);
        }

        public int Update(System.Type type, object[] primaryKeys, string[] columnNames, object[] values)
        {
            return GetDataTableAdapter(type).Update(primaryKeys, values);
        }

        public int Update(System.Type type, string[] columnNames, object[] values)
        {
            return GetDataTableAdapter(type).Update(columnNames, values);
        }

        public int Update(System.Type type, System.Collections.Generic.Dictionary<string, object> values)
        {
            return GetDataTableAdapter(type).Update(values);
        }

        public int Update(System.Type type, object[] primaryKeys, object[] values)
        {
            return GetDataTableAdapter(type).Update(primaryKeys, values);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, UpdateBehavior updateBehavior)
        {
            return GetDataTableAdapter(type).Update(dataRows, updateBehavior);
        }

        public int Update(System.Type type, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(values, transactionID);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return GetDataTableAdapter(type).Update(dataTable, checkConcurrency, updateBehavior);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, string[] columnNames, UpdateBehavior updateBehavior)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnNames, updateBehavior);
        }

        public int Update(System.Type type, string[] columnNames, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(columnNames, transactionID);
        }

        public int Update(System.Type type, object[] primaryKeys, string[] columnNames, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(primaryKeys, columnNames, values, transactionID);
        }

        public int Update(System.Type type, object[] primaryKeys, System.Collections.Generic.Dictionary<string, object> values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(primaryKeys, values, transactionID);
        }

        public int Update(System.Type type, System.Collections.Generic.Dictionary<string, object> values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(values, transactionID);
        }

        public int Update(System.Type type, object[] primaryKeys, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(primaryKeys, values, transactionID);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, string[] columnNames, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnNames, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRows, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, string[] columnNames, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnNames, checkConcurrency, updateBehavior);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataTable, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, string[] columnNames, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnNames, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return GetDataTableAdapter(type).Update(dataRows, checkConcurrency, updateBehavior);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, string[] columnNames, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnNames, checkConcurrency, updateBehavior);
        }

        public int Update(System.Type type, System.Data.DataRow dataRow, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRow, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow dataRow, string[] columnNames, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRow, columnNames, transactionID);
        }

        public int Update(System.Type type, string[] columnNames, object[] originalValues, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(columnNames, originalValues, values, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, bool checkConcurrency)
        {
            return GetDataTableAdapter(type).Update(dataRows, checkConcurrency);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, string[] columnNames, bool checkConcurrency)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnNames, checkConcurrency);
        }

        public int Update(System.Type type, System.Data.DataRow dataRow, bool checkConcurrency)
        {
            return GetDataTableAdapter(type).Update(dataRow, checkConcurrency);
        }

        public int Update(System.Type type, System.Data.DataRow[] dataRows, string[] columnNames, bool checkConcurrency)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnNames, checkConcurrency);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, bool checkConcurrency)
        {
            return GetDataTableAdapter(type).Update(dataTable, checkConcurrency);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, bool checkConcurrency, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataTable, checkConcurrency, transactionID);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, string[] columnNames, bool checkConcurrency, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnNames, checkConcurrency, transactionID);
        }

        public int Update(System.Type type, CommonCommand conditionCommand, System.Collections.Generic.Dictionary<string, object> values)
        {
            return GetDataTableAdapter(type).Update(conditionCommand, values);
        }

        public int Update(System.Type type, CommonCommand conditionCommand, string[] columnNames, object[] values)
        {
            return GetDataTableAdapter(type).Update(conditionCommand, columnNames, values);
        }

        public int Update(System.Type type, CommonCommand conditionCommand, string[] columnNames, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(conditionCommand, columnNames, values, transactionID);
        }

        public int Update(System.Type type, CommonCommand conditionCommand, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(conditionCommand, values, transactionID);
        }

        public int Update(System.Type type, System.Collections.Generic.Dictionary<string, object> originalValues, System.Collections.Generic.Dictionary<string, object> values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(originalValues, values, transactionID);
        }

        public int Update(System.Type type, CommonCommand conditionCommand, System.Collections.Generic.Dictionary<string, object> values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(conditionCommand, values, transactionID);
        }

        public int Update(System.Type type, System.Data.DataRow dataRow, string[] columnNames, bool checkConcurrency)
        {
            return GetDataTableAdapter(type).Update(dataRow, columnNames, checkConcurrency);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, UpdateBehavior updateBehavior)
        {
            return GetDataTableAdapter(type).Update(dataTable, updateBehavior);
        }

        public int Update(System.Type type, System.Data.DataTable dataTable, string[] columnNames, UpdateBehavior updateBehavior)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnNames, updateBehavior);
        }

        public int Update(System.Data.DataTable dataTable, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(dataTable.GetType(), dataTable, checkConcurrency, updateBehavior, transactionID);
        }

        public int Update(System.Data.DataTable dataTable, string[] columnNames, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(dataTable.GetType(), dataTable, columnNames, checkConcurrency, updateBehavior, transactionID);
        }

        public int Update(System.Data.DataRow dataRow, bool checkConcurrency, string transactionID)
        {
            return Update(dataRow.Table.GetType(), dataRow, checkConcurrency, transactionID);
        }

        public int Update(System.Data.DataTable dataTable, string[] columnNames, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(dataTable.GetType(), dataTable, columnNames, updateBehavior, transactionID);
        }

        public int Update(System.Data.DataTable dataTable, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(dataTable.GetType(), dataTable, updateBehavior, transactionID);
        }

        public int Update(System.Data.DataRow dataRow, string[] columnNames, bool checkConcurrency, string transactionID)
        {
            return Update(dataRow.Table.GetType(), dataRow, columnNames, checkConcurrency, transactionID);
        }

        public int Update(System.Data.DataTable dataTable, string[] columnNames)
        {
            return Update(dataTable.GetType(), dataTable, columnNames);
        }

        public int Update(System.Data.DataTable dataTable)
        {
            return Update(dataTable.GetType(), dataTable);
        }

        public int Update(System.Data.DataRow dataRow, string[] columnNames)
        {
            return Update(dataRow.Table.GetType(), dataRow, columnNames);
        }

        public int Update(System.Data.DataRow dataRow)
        {
            return Update(dataRow.Table.GetType(), dataRow);
        }

        public int Update(System.Data.DataTable dataTable, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return Update(dataTable.GetType(), dataTable, checkConcurrency, updateBehavior);
        }

        public int Update(System.Data.DataTable dataTable, string[] columnNames, string transactionID)
        {
            return Update(dataTable.GetType(), dataTable, columnNames, transactionID);
        }

        public int Update(System.Data.DataTable dataTable, string transactionID)
        {
            return Update(dataTable.GetType(), dataTable, transactionID);
        }

        public int Update(System.Data.DataTable dataTable, string[] columnNames, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return Update(dataTable.GetType(), dataTable, columnNames, checkConcurrency, updateBehavior);
        }

        public int Update(System.Data.DataRow dataRow, string transactionID)
        {
            return Update(dataRow.Table.GetType(), dataRow, transactionID);
        }

        public int Update(System.Data.DataRow dataRow, string[] columnNames, string transactionID)
        {
            return Update(dataRow.Table.GetType(), dataRow, columnNames, transactionID);
        }

        public int Update(System.Data.DataTable dataTable, string[] columnNames, bool checkConcurrency)
        {
            return Update(dataTable.GetType(), dataTable, columnNames, checkConcurrency);
        }

        public int Update(System.Data.DataRow dataRow, bool checkConcurrency)
        {
            return Update(dataRow.Table.GetType(), dataRow, checkConcurrency);
        }

        public int Update(System.Data.DataTable dataTable, bool checkConcurrency)
        {
            return Update(dataTable.GetType(), dataTable, checkConcurrency);
        }

        public int Update(System.Data.DataTable dataTable, bool checkConcurrency, string transactionID)
        {
            return Update(dataTable.GetType(), dataTable, checkConcurrency, transactionID);
        }

        public int Update(System.Data.DataTable dataTable, string[] columnNames, bool checkConcurrency, string transactionID)
        {
            return Update(dataTable.GetType(), dataTable, columnNames, checkConcurrency, transactionID);
        }

        public int Update(System.Data.DataRow dataRow, string[] columnNames, bool checkConcurrency)
        {
            return Update(dataRow.Table.GetType(), dataRow, columnNames, checkConcurrency);
        }

        public int Update(System.Data.DataTable dataTable, UpdateBehavior updateBehavior)
        {
            return Update(dataTable.GetType(), dataTable, updateBehavior);
        }

        public int Update(System.Data.DataTable dataTable, string[] columnNames, UpdateBehavior updateBehavior)
        {
            return Update(dataTable.GetType(), dataTable, columnNames, updateBehavior);
        }

        public int UpdateDataTable(System.Type type, System.Data.DataTable dataTable, CommonCommand insertCommand, CommonCommand updateCommand, CommonCommand deleteCommand, UpdateBehavior updateBehavior)
        {
            return GetDataTableAdapter(type).UpdateDataTable(dataTable, insertCommand, updateCommand, deleteCommand, updateBehavior);
        }

        public int UpdateDataTable(System.Type type, System.Data.DataTable dataTable, CommonCommand insertCommand, CommonCommand updateCommand, CommonCommand deleteCommand)
        {
            return GetDataTableAdapter(type).UpdateDataTable(dataTable, insertCommand, updateCommand, deleteCommand);
        }

        public int UpdateDataTable(System.Type type, System.Data.DataTable dataTable, CommonCommand insertCommand, CommonCommand updateCommand, CommonCommand deleteCommand, UpdateBehavior updateBehavior, string transactionID)
        {
            return GetDataTableAdapter(type).UpdateDataTable(dataTable, insertCommand, updateCommand, deleteCommand, updateBehavior, transactionID);
        }

        public int UpdateDataTable(System.Type type, System.Data.DataTable dataTable, CommonCommand insertCommand, CommonCommand updateCommand, CommonCommand deleteCommand, string transactionID)
        {
            return GetDataTableAdapter(type).UpdateDataTable(dataTable, insertCommand, updateCommand, deleteCommand, transactionID);
        }

        public int UpdateDataTable(System.Data.DataTable dataTable, CommonCommand insertCommand, CommonCommand updateCommand, CommonCommand deleteCommand, UpdateBehavior updateBehavior)
        {
            return UpdateDataTable(dataTable.GetType(), dataTable, insertCommand, updateCommand, deleteCommand, updateBehavior);
        }

        public int UpdateDataTable(System.Data.DataTable dataTable, CommonCommand insertCommand, CommonCommand updateCommand, CommonCommand deleteCommand)
        {
            return UpdateDataTable(dataTable.GetType(), dataTable, insertCommand, updateCommand, deleteCommand);
        }

        public int UpdateDataTable(System.Data.DataTable dataTable, CommonCommand insertCommand, CommonCommand updateCommand, CommonCommand deleteCommand, UpdateBehavior updateBehavior, string transactionID)
        {
            return UpdateDataTable(dataTable.GetType(), dataTable, insertCommand, updateCommand, deleteCommand, updateBehavior, transactionID);
        }

        public int UpdateDataTable(System.Data.DataTable dataTable, CommonCommand insertCommand, CommonCommand updateCommand, CommonCommand deleteCommand, string transactionID)
        {
            return UpdateDataTable(dataTable.GetType(), dataTable, insertCommand, updateCommand, deleteCommand, transactionID);
        }
        #endregion
        #region DataObject Functions
        public int DeleteDataObject(System.Type type, object dataObject)
        {
            return GetDataObjectAdapter(type).Delete(dataObject);
        }

        public int DeleteDataObject(System.Type type, object dataObject, string transactionID)
        {
            return GetDataObjectAdapter(type).Delete(dataObject, transactionID);
        }

        public int DeleteDataObject(object dataObject)
        {
            return DeleteDataObject(dataObject.GetType(), dataObject);
        }

        public int DeleteDataObject(object dataObject, string transactionID)
        {
            return DeleteDataObject(dataObject.GetType(), dataObject, transactionID);
        }

        public bool ExistsDataObject(System.Type type, object dataObject)
        {
            return GetDataObjectAdapter(type).Exists(dataObject);
        }

        public bool ExistsDataObject(System.Type type, object dataObject, string transactionID)
        {
            return GetDataObjectAdapter(type).Exists(dataObject, transactionID);
        }

        public bool ExistsDataObject(object dataObject)
        {
            return ExistsDataObject(dataObject.GetType(), dataObject);
        }

        public bool ExistsDataObject(object dataObject, string transactionID)
        {
            return ExistsDataObject(dataObject.GetType(), dataObject, transactionID);
        }

        public int FillDataObject(System.Type type, object dataObject, string transactionID)
        {
            return GetDataObjectAdapter(type).Fill(dataObject, transactionID);
        }

        public int FillDataObject(System.Type type, object dataObject, object[] primaryKeys, string transactionID)
        {
            return GetDataObjectAdapter(type).Fill(dataObject, primaryKeys, transactionID);
        }

        public int FillDataObject(System.Type type, object dataObject, string[] columnNames, string transactionID)
        {
            return GetDataObjectAdapter(type).Fill(dataObject, columnNames, transactionID);
        }

        public int FillDataObject(System.Type type, object dataObject, object[] primaryKeys, string[] columnNames, string transactionID)
        {
            return GetDataObjectAdapter(type).Fill(dataObject, primaryKeys, columnNames, transactionID);
        }

        public int FillDataObject(System.Type type, object dataObject, object[] primaryKeys, string[] columnNames)
        {
            return GetDataObjectAdapter(type).Fill(dataObject, primaryKeys, columnNames);
        }

        public int FillDataObject(System.Type type, object dataObject, string[] columnNames)
        {
            return GetDataObjectAdapter(type).Fill(dataObject, columnNames);
        }

        public int FillDataObject(System.Type type, object dataObject, object[] primaryKeys)
        {
            return GetDataObjectAdapter(type).Fill(dataObject, primaryKeys);
        }

        public int FillDataObject(System.Type type, object dataObject)
        {
            return GetDataObjectAdapter(type).Fill(dataObject);
        }

        public int FillDataObject(object dataObject, string transactionID)
        {
            return FillDataObject(dataObject.GetType(), dataObject, transactionID);
        }

        public int FillDataObject(object dataObject, object[] primaryKeys, string transactionID)
        {
            return FillDataObject(dataObject.GetType(), dataObject, primaryKeys, transactionID);
        }

        public int FillDataObject(object dataObject, string[] columnNames, string transactionID)
        {
            return FillDataObject(dataObject.GetType(), dataObject, columnNames, transactionID);
        }

        public int FillDataObject(object dataObject, object[] primaryKeys, string[] columnNames, string transactionID)
        {
            return FillDataObject(dataObject.GetType(), dataObject, primaryKeys, columnNames, transactionID);
        }

        public int FillDataObject(object dataObject, object[] primaryKeys, string[] columnNames)
        {
            return FillDataObject(dataObject.GetType(), dataObject, primaryKeys, columnNames);
        }

        public int FillDataObject(object dataObject, string[] columnNames)
        {
            return FillDataObject(dataObject.GetType(), dataObject, columnNames);
        }

        public int FillDataObject(object dataObject, object[] primaryKeys)
        {
            return FillDataObject(dataObject.GetType(), dataObject, primaryKeys);
        }

        public int FillDataObject(object dataObject)
        {
            return FillDataObject(dataObject.GetType(), dataObject);
        }

        public object GetDataObject(System.Type type, object dataObject, string[] columnNames, string transactionID)
        {
            return GetDataObjectAdapter(type).GetData(dataObject, columnNames, transactionID);
        }

        public object GetDataObject(System.Type type, object[] primaryKeys)
        {
            return GetDataObjectAdapter(type).GetData(primaryKeys);
        }

        public object GetDataObject(System.Type type, object[] primaryKeys, string[] columnNames, string transactionID)
        {
            return GetDataObjectAdapter(type).GetData(primaryKeys, columnNames, transactionID);
        }

        public object GetDataObject(System.Type type, object[] primaryKeys, string transactionID)
        {
            return GetDataObjectAdapter(type).GetData(primaryKeys, transactionID);
        }

        public object GetDataObject(System.Type type, object dataObject, string transactionID)
        {
            return GetDataObjectAdapter(type).GetData(dataObject, transactionID);
        }

        public object GetDataObject(System.Type type, object[] primaryKeys, string[] columnNames)
        {
            return GetDataObjectAdapter(type).GetData(primaryKeys, columnNames);
        }

        public object GetDataObject(System.Type type, object dataObject, string[] columnNames)
        {
            return GetDataObjectAdapter(type).GetData(dataObject, columnNames);
        }

        public object GetDataObject(System.Type type, object dataObject)
        {
            return GetDataObjectAdapter(type).GetData(dataObject);
        }

        public object GetDataObject(object dataObject, string[] columnNames, string transactionID)
        {
            return GetDataObject(dataObject.GetType(), dataObject, columnNames, transactionID);
        }

        public object GetDataObject(object dataObject, string transactionID)
        {
            return GetDataObject(dataObject.GetType(), dataObject, transactionID);
        }

        public object GetDataObject(object dataObject, string[] columnNames)
        {
            return GetDataObject(dataObject.GetType(), dataObject, columnNames);
        }

        public object GetDataObject(object dataObject)
        {
            return GetDataObject(dataObject.GetType(), dataObject);
        }

        public System.Collections.IList GetDataObjectList(System.Type type, string[] columnNames, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataList(columnNames, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataObjectList(System.Type type, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataList(startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataObjectList(System.Type type, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataList(conditionCommand, transactionID);
        }

        public System.Collections.IList GetDataObjectList(System.Type type, string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataList(columnNames, conditionCommand, transactionID);
        }

        public System.Collections.IList GetDataObjectList(System.Type type, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataList(columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataObjectList(System.Type type, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataList(conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataObjectList(System.Type type, string[] columnNames, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataList(columnNames, transactionID);
        }

        public System.Collections.IList GetDataObjectList(System.Type type, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataList(transactionID);
        }

        public System.Collections.IList GetDataObjectList(System.Type type, string[] columnNames, int startRecord, int maxRecords)
        {
            return GetDataObjectAdapter(type).GetDataList(columnNames, startRecord, maxRecords);
        }

        public System.Collections.IList GetDataObjectList(System.Type type, int startRecord, int maxRecords)
        {
            return GetDataObjectAdapter(type).GetDataList(startRecord, maxRecords);
        }

        public System.Collections.IList GetDataObjectList(System.Type type, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataObjectAdapter(type).GetDataList(columnNames, conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IList GetDataObjectList(System.Type type, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataObjectAdapter(type).GetDataList(conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IList GetDataObjectList(System.Type type, string[] columnNames)
        {
            return GetDataObjectAdapter(type).GetDataList(columnNames);
        }

        public System.Collections.IList GetDataObjectList(System.Type type)
        {
            return GetDataObjectAdapter(type).GetDataList();
        }

        public System.Collections.IList GetDataObjectList(System.Type type, string[] columnNames, CommonCommand conditionCommand)
        {
            return GetDataObjectAdapter(type).GetDataList(columnNames, conditionCommand);
        }

        public System.Collections.IList GetDataObjectList(System.Type type, CommonCommand conditionCommand)
        {
            return GetDataObjectAdapter(type).GetDataList(conditionCommand);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, string[] columnNames, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnNames, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectAdapter(type).GetEnumerator(startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectAdapter(type).GetEnumerator(conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, string[] columnNames, string transactionID)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnNames, transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, string transactionID)
        {
            return GetDataObjectAdapter(type).GetEnumerator(transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnNames, conditionCommand, transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataObjectAdapter(type).GetEnumerator(conditionCommand, transactionID);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, string[] columnNames, int startRecord, int maxRecords)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnNames, startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, int startRecord, int maxRecords)
        {
            return GetDataObjectAdapter(type).GetEnumerator(startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnNames, conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataObjectAdapter(type).GetEnumerator(conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, string[] columnNames)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnNames);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type)
        {
            return GetDataObjectAdapter(type).GetEnumerator();
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, string[] columnNames, CommonCommand conditionCommand)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnNames, conditionCommand);
        }

        public System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, CommonCommand conditionCommand)
        {
            return GetDataObjectAdapter(type).GetEnumerator(conditionCommand);
        }

        public int InsertDataObject(System.Type type, object dataObject, string[] columnNames)
        {
            return GetDataObjectAdapter(type).Insert(dataObject, columnNames);
        }

        public int InsertDataObject(System.Type type, object dataObject)
        {
            return GetDataObjectAdapter(type).Insert(dataObject);
        }

        public int InsertDataObject(System.Type type, object dataObject, string[] columnNames, string transactionID)
        {
            return GetDataObjectAdapter(type).Insert(dataObject, columnNames, transactionID);
        }

        public int InsertDataObject(System.Type type, object dataObject, string transactionID)
        {
            return GetDataObjectAdapter(type).Insert(dataObject, transactionID);
        }

        public int InsertDataObject(object dataObject, string[] columnNames)
        {
            return InsertDataObject(dataObject.GetType(), dataObject, columnNames);
        }

        public int InsertDataObject(object dataObject)
        {
            return InsertDataObject(dataObject.GetType(), dataObject);
        }

        public int InsertDataObject(object dataObject, string[] columnNames, string transactionID)
        {
            return InsertDataObject(dataObject.GetType(), dataObject, columnNames, transactionID);
        }

        public int InsertDataObject(object dataObject, string transactionID)
        {
            return InsertDataObject(dataObject.GetType(), dataObject, transactionID);
        }

        public int SaveDataObject(System.Type type, object dataObject, string transactionID)
        {
            return GetDataObjectAdapter(type).Save(dataObject, transactionID);
        }

        public int SaveDataObject(System.Type type, object dataObject, string[] columnNames)
        {
            return GetDataObjectAdapter(type).Save(dataObject, columnNames);
        }

        public int SaveDataObject(System.Type type, object dataObject, string[] columnNames, string transactionID)
        {
            return GetDataObjectAdapter(type).Save(dataObject, columnNames, transactionID);
        }

        public int SaveDataObject(System.Type type, object dataObject)
        {
            return GetDataObjectAdapter(type).Save(dataObject);
        }

        public int SaveDataObject(object dataObject, string transactionID)
        {
            return SaveDataObject(dataObject.GetType(), dataObject, transactionID);
        }

        public int SaveDataObject(object dataObject, string[] columnNames)
        {
            return SaveDataObject(dataObject.GetType(), dataObject, columnNames);
        }

        public int SaveDataObject(object dataObject, string[] columnNames, string transactionID)
        {
            return SaveDataObject(dataObject.GetType(), dataObject, columnNames, transactionID);
        }

        public int SaveDataObject(object dataObject)
        {
            return SaveDataObject(dataObject.GetType(), dataObject);
        }

        public int UpdateDataObject(System.Type type, object dataObject, string transactionID)
        {
            return GetDataObjectAdapter(type).Update(dataObject, transactionID);
        }

        public int UpdateDataObject(System.Type type, object[] primaryKeys, object dataObject, string[] columnNames)
        {
            return GetDataObjectAdapter(type).Update(primaryKeys, dataObject, columnNames);
        }

        public int UpdateDataObject(System.Type type, object dataObject, string[] columnNames)
        {
            return GetDataObjectAdapter(type).Update(dataObject, columnNames);
        }

        public int UpdateDataObject(System.Type type, object[] primaryKeys, object dataObject)
        {
            return GetDataObjectAdapter(type).Update(primaryKeys, dataObject);
        }

        public int UpdateDataObject(System.Type type, object dataObject)
        {
            return GetDataObjectAdapter(type).Update(dataObject);
        }

        public int UpdateDataObject(System.Type type, object[] primaryKeys, object dataObject, string[] columnNames, string transactionID)
        {
            return GetDataObjectAdapter(type).Update(primaryKeys, dataObject, columnNames, transactionID);
        }

        public int UpdateDataObject(System.Type type, object[] primaryKeys, object dataObject, string transactionID)
        {
            return GetDataObjectAdapter(type).Update(primaryKeys, dataObject, transactionID);
        }

        public int UpdateDataObject(System.Type type, object dataObject, string[] columnNames, string transactionID)
        {
            return GetDataObjectAdapter(type).Update(dataObject, columnNames, transactionID);
        }

        public int UpdateDataObject(object dataObject, string transactionID)
        {
            return UpdateDataObject(dataObject.GetType(), dataObject, transactionID);
        }

        public int UpdateDataObject(object dataObject, string[] columnNames)
        {
            return UpdateDataObject(dataObject.GetType(), dataObject, columnNames);
        }

        public int UpdateDataObject(object dataObject)
        {
            return UpdateDataObject(dataObject.GetType(), dataObject);
        }

        public int UpdateDataObject(object dataObject, string[] columnNames, string transactionID)
        {
            return UpdateDataObject(dataObject.GetType(), dataObject, columnNames, transactionID);
        }
        #endregion
        #region DataItem Functions
        public int DeleteDataItem(System.Type type, DataItem dataItem)
        {
            return GetDataItemAdapter(type).Delete(dataItem);
        }

        public int DeleteDataItem(System.Type type, DataItem dataItem, string transactionID)
        {
            return GetDataItemAdapter(type).Delete(dataItem, transactionID);
        }

        public int DeleteDataItem(DataItem dataItem)
        {
            return DeleteDataItem(dataItem.GetType(), dataItem);
        }

        public int DeleteDataItem(DataItem dataItem, string transactionID)
        {
            return DeleteDataItem(dataItem.GetType(), dataItem, transactionID);
        }

        public bool ExistsDataItem(System.Type type, DataItem dataItem, string transactionID)
        {
            return GetDataItemAdapter(type).Exists(dataItem, transactionID);
        }

        public bool ExistsDataItem(System.Type type, DataItem dataItem)
        {
            return GetDataItemAdapter(type).Exists(dataItem);
        }

        public bool ExistsDataItem(DataItem dataItem, string transactionID)
        {
            return ExistsDataItem(dataItem.GetType(), dataItem, transactionID);
        }

        public bool ExistsDataItem(DataItem dataItem)
        {
            return ExistsDataItem(dataItem.GetType(), dataItem);
        }

        public int FillDataItem(System.Type type, DataItem dataItem, object[] primaryKeys)
        {
            return GetDataItemAdapter(type).Fill(dataItem, primaryKeys);
        }

        public int FillDataItem(System.Type type, DataItem dataItem, string transactionID)
        {
            return GetDataItemAdapter(type).Fill(dataItem, transactionID);
        }

        public int FillDataItem(System.Type type, DataItem dataItem, object[] primaryKeys, string transactionID)
        {
            return GetDataItemAdapter(type).Fill(dataItem, primaryKeys, transactionID);
        }

        public int FillDataItem(System.Type type, DataItem dataItem, string[] columnNames, string transactionID)
        {
            return GetDataItemAdapter(type).Fill(dataItem, columnNames, transactionID);
        }

        public int FillDataItem(System.Type type, DataItem dataItem, object[] primaryKeys, string[] columnNames, string transactionID)
        {
            return GetDataItemAdapter(type).Fill(dataItem, primaryKeys, columnNames, transactionID);
        }

        public int FillDataItem(System.Type type, DataItem dataItem, string[] columnNames)
        {
            return GetDataItemAdapter(type).Fill(dataItem, columnNames);
        }

        public int FillDataItem(System.Type type, DataItem dataItem, object[] primaryKeys, string[] columnNames)
        {
            return GetDataItemAdapter(type).Fill(dataItem, primaryKeys, columnNames);
        }

        public int FillDataItem(System.Type type, DataItem dataItem)
        {
            return GetDataItemAdapter(type).Fill(dataItem);
        }

        public int FillDataItem(DataItem dataItem, object[] primaryKeys)
        {
            return FillDataItem(dataItem.GetType(), dataItem, primaryKeys);
        }

        public int FillDataItem(DataItem dataItem, string transactionID)
        {
            return FillDataItem(dataItem.GetType(), dataItem, transactionID);
        }

        public int FillDataItem(DataItem dataItem, object[] primaryKeys, string transactionID)
        {
            return FillDataItem(dataItem.GetType(), dataItem, primaryKeys, transactionID);
        }

        public int FillDataItem(DataItem dataItem, string[] columnNames, string transactionID)
        {
            return FillDataItem(dataItem.GetType(), dataItem, columnNames, transactionID);
        }

        public int FillDataItem(DataItem dataItem, object[] primaryKeys, string[] columnNames, string transactionID)
        {
            return FillDataItem(dataItem.GetType(), dataItem, primaryKeys, columnNames, transactionID);
        }

        public int FillDataItem(DataItem dataItem, string[] columnNames)
        {
            return FillDataItem(dataItem.GetType(), dataItem, columnNames);
        }

        public int FillDataItem(DataItem dataItem, object[] primaryKeys, string[] columnNames)
        {
            return FillDataItem(dataItem.GetType(), dataItem, primaryKeys, columnNames);
        }

        public int FillDataItem(DataItem dataItem)
        {
            return FillDataItem(dataItem.GetType(), dataItem);
        }

        public DataItem GetDataItem(System.Type type, object[] primaryKeys, string transactionID)
        {
            return GetDataItemAdapter(type).GetData(primaryKeys, transactionID);
        }

        public DataItem GetDataItem(System.Type type, object[] primaryKeys)
        {
            return GetDataItemAdapter(type).GetData(primaryKeys);
        }

        public DataItem GetDataItem(System.Type type, DataItem dataItem, string[] columnNames, string transactionID)
        {
            return GetDataItemAdapter(type).GetData(dataItem, columnNames, transactionID);
        }

        public DataItem GetDataItem(System.Type type, DataItem dataItem, string transactionID)
        {
            return GetDataItemAdapter(type).GetData(dataItem, transactionID);
        }

        public DataItem GetDataItem(System.Type type, object[] primaryKeys, string[] columnNames, string transactionID)
        {
            return GetDataItemAdapter(type).GetData(primaryKeys, columnNames, transactionID);
        }

        public DataItem GetDataItem(System.Type type, DataItem dataItem)
        {
            return GetDataItemAdapter(type).GetData(dataItem);
        }

        public DataItem GetDataItem(System.Type type, DataItem dataItem, string[] columnNames)
        {
            return GetDataItemAdapter(type).GetData(dataItem, columnNames);
        }

        public DataItem GetDataItem(System.Type type, object[] primaryKeys, string[] columnNames)
        {
            return GetDataItemAdapter(type).GetData(primaryKeys, columnNames);
        }

        public DataItem GetDataItem(DataItem dataItem, string[] columnNames, string transactionID)
        {
            return GetDataItem(dataItem.GetType(), dataItem, columnNames, transactionID);
        }

        public DataItem GetDataItem(DataItem dataItem, string transactionID)
        {
            return GetDataItem(dataItem.GetType(), dataItem, transactionID);
        }

        public DataItem GetDataItem(DataItem dataItem)
        {
            return GetDataItem(dataItem.GetType(), dataItem);
        }

        public DataItem GetDataItem(DataItem dataItem, string[] columnNames)
        {
            return GetDataItem(dataItem.GetType(), dataItem, columnNames);
        }

        public System.Collections.IList GetDataItemList(System.Type type, string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataList(columnNames, conditionCommand, transactionID);
        }

        public System.Collections.IList GetDataItemList(System.Type type, string[] columnNames, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataList(columnNames, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataItemList(System.Type type, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataList(conditionCommand, transactionID);
        }

        public System.Collections.IList GetDataItemList(System.Type type, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataList(transactionID);
        }

        public System.Collections.IList GetDataItemList(System.Type type, string[] columnNames, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataList(columnNames, transactionID);
        }

        public System.Collections.IList GetDataItemList(System.Type type, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataList(startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataItemList(System.Type type, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataList(columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataItemList(System.Type type, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataList(conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IList GetDataItemList(System.Type type, string[] columnNames, int startRecord, int maxRecords)
        {
            return GetDataItemAdapter(type).GetDataList(columnNames, startRecord, maxRecords);
        }

        public System.Collections.IList GetDataItemList(System.Type type, int startRecord, int maxRecords)
        {
            return GetDataItemAdapter(type).GetDataList(startRecord, maxRecords);
        }

        public System.Collections.IList GetDataItemList(System.Type type, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataItemAdapter(type).GetDataList(columnNames, conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IList GetDataItemList(System.Type type, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataItemAdapter(type).GetDataList(conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IList GetDataItemList(System.Type type, string[] columnNames)
        {
            return GetDataItemAdapter(type).GetDataList(columnNames);
        }

        public System.Collections.IList GetDataItemList(System.Type type)
        {
            return GetDataItemAdapter(type).GetDataList();
        }

        public System.Collections.IList GetDataItemList(System.Type type, string[] columnNames, CommonCommand conditionCommand)
        {
            return GetDataItemAdapter(type).GetDataList(columnNames, conditionCommand);
        }

        public System.Collections.IList GetDataItemList(System.Type type, CommonCommand conditionCommand)
        {
            return GetDataItemAdapter(type).GetDataList(conditionCommand);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, string[] columnNames, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnNames, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemAdapter(type).GetEnumerator(startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnNames, conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, CommonCommand conditionCommand, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemAdapter(type).GetEnumerator(conditionCommand, startRecord, maxRecords, transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, string[] columnNames, string transactionID)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnNames, transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, string transactionID)
        {
            return GetDataItemAdapter(type).GetEnumerator(transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, string[] columnNames, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnNames, conditionCommand, transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataItemAdapter(type).GetEnumerator(conditionCommand, transactionID);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataItemAdapter(type).GetEnumerator(conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, string[] columnNames, int startRecord, int maxRecords)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnNames, startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type)
        {
            return GetDataItemAdapter(type).GetEnumerator();
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, string[] columnNames, CommonCommand conditionCommand, int startRecord, int maxRecords)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnNames, conditionCommand, startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, CommonCommand conditionCommand)
        {
            return GetDataItemAdapter(type).GetEnumerator(conditionCommand);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, string[] columnNames)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnNames);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, int startRecord, int maxRecords)
        {
            return GetDataItemAdapter(type).GetEnumerator(startRecord, maxRecords);
        }

        public System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, string[] columnNames, CommonCommand conditionCommand)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnNames, conditionCommand);
        }

        public int InsertDataItem(System.Type type, DataItem dataItem)
        {
            return GetDataItemAdapter(type).Insert(dataItem);
        }

        public int InsertDataItem(System.Type type, DataItem dataItem, string[] columnNames)
        {
            return GetDataItemAdapter(type).Insert(dataItem, columnNames);
        }

        public int InsertDataItem(System.Type type, DataItem dataItem, string transactionID)
        {
            return GetDataItemAdapter(type).Insert(dataItem, transactionID);
        }

        public int InsertDataItem(System.Type type, DataItem dataItem, string[] columnNames, string transactionID)
        {
            return GetDataItemAdapter(type).Insert(dataItem, columnNames, transactionID);
        }

        public int InsertDataItem(DataItem dataItem)
        {
            return InsertDataItem(dataItem.GetType(), dataItem);
        }

        public int InsertDataItem(DataItem dataItem, string[] columnNames)
        {
            return InsertDataItem(dataItem.GetType(), dataItem, columnNames);
        }

        public int InsertDataItem(DataItem dataItem, string transactionID)
        {
            return InsertDataItem(dataItem.GetType(), dataItem, transactionID);
        }

        public int InsertDataItem(DataItem dataItem, string[] columnNames, string transactionID)
        {
            return InsertDataItem(dataItem.GetType(), dataItem, columnNames, transactionID);
        }

        public int SaveDataItem(System.Type type, DataItem dataItem, string[] columnNames, string transactionID)
        {
            return GetDataItemAdapter(type).Save(dataItem, columnNames, transactionID);
        }

        public int SaveDataItem(System.Type type, DataItem dataItem)
        {
            return GetDataItemAdapter(type).Save(dataItem);
        }

        public int SaveDataItem(System.Type type, DataItem dataItem, string[] columnNames)
        {
            return GetDataItemAdapter(type).Save(dataItem, columnNames);
        }

        public int SaveDataItem(System.Type type, DataItem dataItem, string transactionID)
        {
            return GetDataItemAdapter(type).Save(dataItem, transactionID);
        }

        public int SaveDataItem(DataItem dataItem, string[] columnNames, string transactionID)
        {
            return SaveDataItem(dataItem.GetType(), dataItem, columnNames, transactionID);
        }

        public int SaveDataItem(DataItem dataItem)
        {
            return SaveDataItem(dataItem.GetType(), dataItem);
        }

        public int SaveDataItem(DataItem dataItem, string[] columnNames)
        {
            return SaveDataItem(dataItem.GetType(), dataItem, columnNames);
        }

        public int SaveDataItem(DataItem dataItem, string transactionID)
        {
            return SaveDataItem(dataItem.GetType(), dataItem, transactionID);
        }

        public int UpdateDataItem(System.Type type, object[] primaryKeys, DataItem dataItem, string transactionID)
        {
            return GetDataItemAdapter(type).Update(primaryKeys, dataItem, transactionID);
        }

        public int UpdateDataItem(System.Type type, DataItem dataItem, string transactionID)
        {
            return GetDataItemAdapter(type).Update(dataItem, transactionID);
        }

        public int UpdateDataItem(System.Type type, object[] primaryKeys, DataItem dataItem, string[] columnNames)
        {
            return GetDataItemAdapter(type).Update(primaryKeys, dataItem, columnNames);
        }

        public int UpdateDataItem(System.Type type, object[] primaryKeys, DataItem dataItem)
        {
            return GetDataItemAdapter(type).Update(primaryKeys, dataItem);
        }

        public int UpdateDataItem(System.Type type, DataItem dataItem)
        {
            return GetDataItemAdapter(type).Update(dataItem);
        }

        public int UpdateDataItem(System.Type type, DataItem dataItem, string[] columnNames)
        {
            return GetDataItemAdapter(type).Update(dataItem, columnNames);
        }

        public int UpdateDataItem(System.Type type, DataItem dataItem, string[] columnNames, string transactionID)
        {
            return GetDataItemAdapter(type).Update(dataItem, columnNames, transactionID);
        }

        public int UpdateDataItem(System.Type type, object[] primaryKeys, DataItem dataItem, string[] columnNames, string transactionID)
        {
            return GetDataItemAdapter(type).Update(primaryKeys, dataItem, columnNames, transactionID);
        }

        public int UpdateDataItem(DataItem dataItem, string transactionID)
        {
            return UpdateDataItem(dataItem.GetType(), dataItem, transactionID);
        }

        public int UpdateDataItem(DataItem dataItem)
        {
            return UpdateDataItem(dataItem.GetType(), dataItem);
        }

        public int UpdateDataItem(DataItem dataItem, string[] columnNames)
        {
            return UpdateDataItem(dataItem.GetType(), dataItem, columnNames);
        }

        public int UpdateDataItem(DataItem dataItem, string[] columnNames, string transactionID)
        {
            return UpdateDataItem(dataItem.GetType(), dataItem, columnNames, transactionID);
        }
        #endregion
        #region DataSet Functions
        public int DeleteByRelation(System.Type type, string tableName, object[] primaryKeys)
        {
            return GetDataSetAdapter(type).DeleteByRelation(tableName, primaryKeys);
        }

        public int DeleteByRelation(System.Type type, string tableName, CommonCommand conditionCommand)
        {
            return GetDataSetAdapter(type).DeleteByRelation(tableName, conditionCommand);
        }

        public int DeleteByRelation(System.Type type, string tableName, object[] primaryKeys, string transactionID)
        {
            return GetDataSetAdapter(type).DeleteByRelation(tableName, primaryKeys, transactionID);
        }

        public int DeleteByRelation(System.Type type, string tableName, CommonCommand conditionCommand, string transactionID)
        {
            return GetDataSetAdapter(type).DeleteByRelation(tableName, conditionCommand, transactionID);
        }

        public int ExecuteDataSetNonQueryCommand(System.Type type, CommonCommand commonCommand, string transactionID)
        {
            return GetDataSetAdapter(type).ExecuteNonQueryCommand(commonCommand, transactionID);
        }

        public int ExecuteDataSetNonQueryCommand(System.Type type, CommonCommand commonCommand)
        {
            return GetDataSetAdapter(type).ExecuteNonQueryCommand(commonCommand);
        }

        public System.Data.IDataReader ExecuteDataSetReaderCommand(System.Type type, CommonCommand commonCommand)
        {
            return GetDataSetAdapter(type).ExecuteReaderCommand(commonCommand);
        }

        public System.Data.IDataReader ExecuteDataSetReaderCommand(System.Type type, CommonCommand commonCommand, string transactionID)
        {
            return GetDataSetAdapter(type).ExecuteReaderCommand(commonCommand, transactionID);
        }

        public object ExecuteDataSetScalarCommand(System.Type type, CommonCommand commonCommand, string transactionID)
        {
            return GetDataSetAdapter(type).ExecuteScalarCommand(commonCommand, transactionID);
        }

        public object ExecuteDataSetScalarCommand(System.Type type, CommonCommand commonCommand)
        {
            return GetDataSetAdapter(type).ExecuteScalarCommand(commonCommand);
        }

        public int Fill(System.Type type, System.Data.DataSet dataSet, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID)
        {
            return GetDataSetAdapter(type).Fill(dataSet, columnNamesDictionary, transactionID);
        }

        public int Fill(System.Type type, System.Data.DataSet dataSet, string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary)
        {
            return GetDataSetAdapter(type).Fill(dataSet, tableNames, columnNamesDictionary);
        }

        public int Fill(System.Type type, System.Data.DataSet dataSet, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary)
        {
            return GetDataSetAdapter(type).Fill(dataSet, columnNamesDictionary);
        }

        public int Fill(System.Type type, System.Data.DataSet dataSet, string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID)
        {
            return GetDataSetAdapter(type).Fill(dataSet, tableNames, columnNamesDictionary, transactionID);
        }

        public int Fill(System.Type type, System.Data.DataSet dataSet, string transactionID)
        {
            return GetDataSetAdapter(type).Fill(dataSet, transactionID);
        }

        public int Fill(System.Type type, System.Data.DataSet dataSet, string[] tableNames, string transactionID)
        {
            return GetDataSetAdapter(type).Fill(dataSet, tableNames, transactionID);
        }

        public int Fill(System.Type type, System.Data.DataSet dataSet, string[] tableNames)
        {
            return GetDataSetAdapter(type).Fill(dataSet, tableNames);
        }

        public int Fill(System.Type type, System.Data.DataSet dataSet)
        {
            return GetDataSetAdapter(type).Fill(dataSet);
        }

        public int Fill(System.Data.DataSet dataSet, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID)
        {
            return Fill(dataSet.GetType(), dataSet, columnNamesDictionary, transactionID);
        }

        public int Fill(System.Data.DataSet dataSet, string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary)
        {
            return Fill(dataSet.GetType(), dataSet, tableNames, columnNamesDictionary);
        }

        public int Fill(System.Data.DataSet dataSet, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary)
        {
            return Fill(dataSet.GetType(), dataSet, columnNamesDictionary);
        }

        public int Fill(System.Data.DataSet dataSet, string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID)
        {
            return Fill(dataSet.GetType(), dataSet, tableNames, columnNamesDictionary, transactionID);
        }

        public int Fill(System.Data.DataSet dataSet, string transactionID)
        {
            return Fill(dataSet.GetType(), dataSet, transactionID);
        }

        public int Fill(System.Data.DataSet dataSet, string[] tableNames, string transactionID)
        {
            return Fill(dataSet.GetType(), dataSet, tableNames, transactionID);
        }

        public int Fill(System.Data.DataSet dataSet, string[] tableNames)
        {
            return Fill(dataSet.GetType(), dataSet, tableNames);
        }

        public int Fill(System.Data.DataSet dataSet)
        {
            return Fill(dataSet.GetType(), dataSet);
        }

        public int FillByRelation(System.Type type, System.Data.DataSet dataSet, string tableName, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, CommonCommand conditionCommand, bool viewMode)
        {
            return GetDataSetAdapter(type).FillByRelation(dataSet, tableName, columnNamesDictionary, conditionCommand, viewMode);
        }

        public int FillByRelation(System.Type type, System.Data.DataSet dataSet, string tableName, object[] primaryKeys, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, bool viewMode)
        {
            return GetDataSetAdapter(type).FillByRelation(dataSet, tableName, primaryKeys, columnNamesDictionary, viewMode);
        }

        public int FillByRelation(System.Type type, System.Data.DataSet dataSet, string tableName, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, CommonCommand conditionCommand, bool viewMode, string transactionID)
        {
            return GetDataSetAdapter(type).FillByRelation(dataSet, tableName, columnNamesDictionary, conditionCommand, viewMode, transactionID);
        }

        public int FillByRelation(System.Type type, System.Data.DataSet dataSet, string tableName, object[] primaryKeys, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, bool viewMode, string transactionID)
        {
            return GetDataSetAdapter(type).FillByRelation(dataSet, tableName, primaryKeys, columnNamesDictionary, viewMode, transactionID);
        }

        public int FillByRelation(System.Data.DataSet dataSet, string tableName, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, CommonCommand conditionCommand, bool viewMode)
        {
            return FillByRelation(dataSet.GetType(), dataSet, tableName, columnNamesDictionary, conditionCommand, viewMode);
        }

        public int FillByRelation(System.Data.DataSet dataSet, string tableName, object[] primaryKeys, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, bool viewMode)
        {
            return FillByRelation(dataSet.GetType(), dataSet, tableName, primaryKeys, columnNamesDictionary, viewMode);
        }

        public int FillByRelation(System.Data.DataSet dataSet, string tableName, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, CommonCommand conditionCommand, bool viewMode, string transactionID)
        {
            return FillByRelation(dataSet.GetType(), dataSet, tableName, columnNamesDictionary, conditionCommand, viewMode, transactionID);
        }

        public int FillByRelation(System.Data.DataSet dataSet, string tableName, object[] primaryKeys, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, bool viewMode, string transactionID)
        {
            return FillByRelation(dataSet.GetType(), dataSet, tableName, primaryKeys, columnNamesDictionary, viewMode, transactionID);
        }

        public System.Data.DataSet GetDataSet(System.Type type, string[] tableNames, string transactionID)
        {
            return GetDataSetAdapter(type).GetData(tableNames, transactionID);
        }

        public System.Data.DataSet GetDataSet(System.Type type, string transactionID)
        {
            return GetDataSetAdapter(type).GetData(transactionID);
        }

        public System.Data.DataSet GetDataSet(System.Type type, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary)
        {
            return GetDataSetAdapter(type).GetData(columnNamesDictionary);
        }

        public System.Data.DataSet GetDataSet(System.Type type, string[] tableNames)
        {
            return GetDataSetAdapter(type).GetData(tableNames);
        }

        public System.Data.DataSet GetDataSet(System.Type type)
        {
            return GetDataSetAdapter(type).GetData();
        }

        public System.Data.DataSet GetDataSet(System.Type type, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID)
        {
            return GetDataSetAdapter(type).GetData(columnNamesDictionary, transactionID);
        }

        public System.Data.DataSet GetDataSet(System.Type type, string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary)
        {
            return GetDataSetAdapter(type).GetData(tableNames, columnNamesDictionary);
        }

        public System.Data.DataSet GetDataSet(System.Type type, string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID)
        {
            return GetDataSetAdapter(type).GetData(tableNames, columnNamesDictionary, transactionID);
        }

        public System.Data.DataSet GetDataByRelation(System.Type type, string tableName, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, CommonCommand conditionCommand, bool viewMode, string transactionID)
        {
            return GetDataSetAdapter(type).GetDataByRelation(tableName, columnNamesDictionary, conditionCommand, viewMode, transactionID);
        }

        public System.Data.DataSet GetDataByRelation(System.Type type, string tableName, object[] primaryKeys, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, bool viewMode, string transactionID)
        {
            return GetDataSetAdapter(type).GetDataByRelation(tableName, primaryKeys, columnNamesDictionary, viewMode, transactionID);
        }

        public System.Data.DataSet GetDataByRelation(System.Type type, string tableName, object[] primaryKeys, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, bool viewMode)
        {
            return GetDataSetAdapter(type).GetDataByRelation(tableName, primaryKeys, columnNamesDictionary, viewMode);
        }

        public System.Data.DataSet GetDataByRelation(System.Type type, string tableName, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, CommonCommand conditionCommand, bool viewMode)
        {
            return GetDataSetAdapter(type).GetDataByRelation(tableName, columnNamesDictionary, conditionCommand, viewMode);
        }

        public int Update(System.Type type, System.Data.DataSet dataSet, string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary)
        {
            return GetDataSetAdapter(type).Update(dataSet, tableNames, columnNamesDictionary);
        }

        public int Update(System.Type type, System.Data.DataSet dataSet, string transactionID)
        {
            return GetDataSetAdapter(type).Update(dataSet, transactionID);
        }

        public int Update(System.Type type, System.Data.DataSet dataSet, string[] tableNames, string transactionID)
        {
            return GetDataSetAdapter(type).Update(dataSet, tableNames, transactionID);
        }

        public int Update(System.Type type, System.Data.DataSet dataSet, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary)
        {
            return GetDataSetAdapter(type).Update(dataSet, columnNamesDictionary);
        }

        public int Update(System.Type type, System.Data.DataSet dataSet, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID)
        {
            return GetDataSetAdapter(type).Update(dataSet, columnNamesDictionary);
        }

        public int Update(System.Type type, System.Data.DataSet dataSet, string[] tableNames)
        {
            return GetDataSetAdapter(type).Update(dataSet, tableNames);
        }

        public int Update(System.Type type, System.Data.DataSet dataSet)
        {
            return GetDataSetAdapter(type).Update(dataSet);
        }

        public int Update(System.Type type, System.Data.DataSet dataSet, string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID)
        {
            return GetDataSetAdapter(type).Update(dataSet, tableNames, columnNamesDictionary, transactionID);
        }

        public int Update(System.Data.DataSet dataSet, string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary)
        {
            return Update(dataSet.GetType(), dataSet, columnNamesDictionary);
        }

        public int Update(System.Data.DataSet dataSet, string transactionID)
        {
            return Update(dataSet.GetType(), dataSet, transactionID);
        }

        public int Update(System.Data.DataSet dataSet, string[] tableNames, string transactionID)
        {
            return Update(dataSet.GetType(), tableNames, transactionID);
        }

        public int Update(System.Data.DataSet dataSet, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary)
        {
            return Update(dataSet.GetType(), dataSet, columnNamesDictionary);
        }

        public int Update(System.Data.DataSet dataSet, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID)
        {
            return Update(dataSet.GetType(), dataSet, columnNamesDictionary, transactionID);
        }

        public int Update(System.Data.DataSet dataSet, string[] tableNames)
        {
            return Update(dataSet.GetType(), dataSet, tableNames);
        }

        public int Update(System.Data.DataSet dataSet)
        {
            return Update(dataSet.GetType(), dataSet);
        }

        public int Update(System.Data.DataSet dataSet, string[] tableNames, System.Collections.Generic.Dictionary<string, string[]> columnNamesDictionary, string transactionID)
        {
            return Update(dataSet.GetType(), dataSet, tableNames, columnNamesDictionary, transactionID);
        }
        #endregion
 
        #region Extension Functions
        #region DataTable Functions 
        #region Common Methods
        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Type type, System.Data.DataTable dataTable, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).Fill(dataTable, conditionExpression);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnExpressions, conditionExpression);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Data.DataTable dataTable, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return Fill(dataTable.GetType(), dataTable, conditionExpression);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return Fill(dataTable.GetType(), dataTable, columnExpressions, conditionExpression);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillByPrimaryKey(System.Type type, System.Data.DataTable dataTable, object primaryKey)
        {
            return GetDataTableAdapter(type).FillByPrimaryKey(dataTable, primaryKey);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillByPrimaryKey(System.Type type, System.Data.DataTable dataTable, object primaryKey, ColumnExpression[] columnExpressions)
        {
            return GetDataTableAdapter(type).FillByPrimaryKey(dataTable, primaryKey, columnExpressions);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillByPrimaryKey(System.Data.DataTable dataTable, object primaryKey)
        {
            return FillByPrimaryKey(dataTable.GetType(), dataTable, primaryKey);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillByPrimaryKey(System.Data.DataTable dataTable, object primaryKey, ColumnExpression[] columnExpressions)
        {
            return FillByPrimaryKey(dataTable.GetType(), dataTable, primaryKey, columnExpressions);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTable(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).GetData(conditionExpression);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTable(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).GetData(columnExpressions, conditionExpression);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTableByPrimaryKey(System.Type type, object primaryKey)
        {
            return GetDataTableAdapter(type).GetDataByPrimaryKey(primaryKey);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTableByPrimaryKey(System.Type type, object primaryKey, ColumnExpression[] columnExpressions)
        {
            return GetDataTableAdapter(type).GetDataByPrimaryKey(primaryKey, columnExpressions);
        }

        /// <summary>
        /// Delete data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByPrimaryKey(System.Type type, object primaryKey)
        {
            return GetDataTableAdapter(type).DeleteByPrimaryKey(primaryKey);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Delete(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).Delete(conditionExpression);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateByPrimaryKey(System.Type type, object primaryKey, object[] values)
        {
            return GetDataTableAdapter(type).UpdateByPrimaryKey(primaryKey, values);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateByPrimaryKey(System.Type type, object primaryKey, ColumnExpression[] columnExpressions, object[] values)
        {
            return GetDataTableAdapter(type).UpdateByPrimaryKey(primaryKey, columnExpressions, values);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateByPrimaryKey(System.Type type, object primaryKey, Dictionary<string, object> values)
        {
            return GetDataTableAdapter(type).UpdateByPrimaryKey(primaryKey, values);
        }

        /// <summary>
        /// Update the data according the condition.
        /// </summary>
        /// <remarks>
        /// Pay attention to the parameter name in the addtion condtion.
        /// </remarks>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, object[] values)
        {
            return GetDataTableAdapter(type).Update(conditionExpression, values);
        }

        /// <summary>
        /// Update the data according the condition.
        /// </summary>
        /// <remarks>
        /// Pay attention to the parameter name in the addtion condtion.
        /// </remarks>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, ColumnExpression[] columnExpressions, object[] values)
        {
            return GetDataTableAdapter(type).Update(conditionExpression, columnExpressions, values);
        }

        /// <summary>
        /// Update the data according the condition.
        /// </summary>
        /// <remarks>
        /// Pay attention to the parameter name in the addtion condtion.
        /// </remarks>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, Dictionary<string, object> values)
        {
            return GetDataTableAdapter(type).Update(conditionExpression, values);
        }

        /// <summary>
        /// Check the data by primary key.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>If exists then return true, otherwise return false.</returns>
        public virtual bool ExistsByPrimaryKey(System.Type type, object primaryKey)
        {
            return GetDataTableAdapter(type).ExistsByPrimaryKey(primaryKey);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Type type, System.Data.DataTable dataTable, RaisingStudio.Data.Expressions.ColumnExpression[] columnExpressions)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnExpressions);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Type type, System.Data.DataTable dataTable, object[] primaryKeys, ColumnExpression[] columnExpressions)
        {
            return GetDataTableAdapter(type).Fill(dataTable, primaryKeys, columnExpressions);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Data.DataTable dataTable, RaisingStudio.Data.Expressions.ColumnExpression[] columnExpressions)
        {
            return Fill(dataTable.GetType(), dataTable, columnExpressions);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Data.DataTable dataTable, object[] primaryKeys, ColumnExpression[] columnExpressions)
        {
            return Fill(dataTable.GetType(), dataTable, primaryKeys, columnExpressions);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTable(System.Type type, ColumnExpression[] columnExpressions)
        {
            return GetDataTableAdapter(type).GetData(columnExpressions);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTable(System.Type type, object[] primaryKeys, ColumnExpression[] columnExpressions)
        {
            return GetDataTableAdapter(type).GetData(primaryKeys, columnExpressions);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnExpressions);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnExpressions);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRow">Datarow.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataRow dataRow, ColumnExpression[] columnExpressions)
        {
            return GetDataTableAdapter(type).Update(dataRow, columnExpressions);
        }

        /// <summary>
        /// Delete data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="originalValues">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Delete(System.Type type, ColumnExpression[] columnExpressions, object[] originalValues)
        {
            return GetDataTableAdapter(type).Delete(columnExpressions, originalValues);
        }

        /// <summary>
        /// Insert data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Insert(System.Type type, ColumnExpression[] columnExpressions, object[] values)
        {
            return GetDataTableAdapter(type).Insert(columnExpressions, values);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, ColumnExpression[] columnExpressions, object[] values)
        {
            return GetDataTableAdapter(type).Update(columnExpressions, values);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, object[] primaryKeys, ColumnExpression[] columnExpressions, object[] values)
        {
            return GetDataTableAdapter(type).Update(primaryKeys, columnExpressions, values);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="originalValues">The original values.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, ColumnExpression[] columnExpressions, object[] originalValues, object[] values)
        {
            return GetDataTableAdapter(type).Update(columnExpressions, originalValues, values);
        }

        #region Normal Functions
        /// <summary>
        /// Gets the data row count according the condition.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The count of data rows.</returns>
        public virtual int GetDataCount(System.Type type, ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).GetDataCount(conditionExpression);
        }

        /// <summary>
        /// Gets the sum of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the sum of data.</returns>
        public virtual object GetSumData(System.Type type, ColumnExpression columnExpression)
        {
            return GetDataTableAdapter(type).GetSumData(columnExpression);
        }

        /// <summary>
        /// Gets the sum of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the sum of data.</returns>
        public virtual object GetSumData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).GetSumData(columnExpression, conditionExpression);
        }

        /// <summary>
        /// Gets the avg of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the avg of data.</returns>
        public virtual object GetAvgData(System.Type type, ColumnExpression columnExpression)
        {
            return GetDataTableAdapter(type).GetAvgData(columnExpression);
        }

        /// <summary>
        /// Gets the avg of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the avg of data.</returns>
        public virtual object GetAvgData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).GetAvgData(columnExpression, conditionExpression);
        }

        /// <summary>
        /// Gets the max of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the max of data.</returns>
        public virtual object GetMaxData(System.Type type, ColumnExpression columnExpression)
        {
            return GetDataTableAdapter(type).GetMaxData(columnExpression);
        }

        /// <summary>
        /// Get the max of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the max of data.</returns>
        public virtual object GetMaxData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).GetMaxData(columnExpression, conditionExpression);
        }

        /// <summary>
        /// Gets the min of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the min of data.</returns>
        public virtual object GetMinData(System.Type type, ColumnExpression columnExpression)
        {
            return GetDataTableAdapter(type).GetMinData(columnExpression);
        }

        /// <summary>
        /// Get the min of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the min of data.</returns>
        public virtual object GetMinData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).GetMinData(columnExpression, conditionExpression);
        }
        #endregion

        #region 并发冲突及Update 行为
        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, bool checkConcurrency)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnExpressions, checkConcurrency);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, bool checkConcurrency)
        {
            return Update(dataTable.GetType(), dataTable, columnExpressions, checkConcurrency);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions, bool checkConcurrency)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnExpressions, checkConcurrency);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRow">Datarow.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataRow dataRow, ColumnExpression[] columnExpressions, bool checkConcurrency)
        {
            return GetDataTableAdapter(type).Update(dataRow, columnExpressions, checkConcurrency);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, UpdateBehavior updateBehavior)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnExpressions, updateBehavior);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, UpdateBehavior updateBehavior)
        {
            return Update(dataTable.GetType(), dataTable, columnExpressions, updateBehavior);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions, UpdateBehavior updateBehavior)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnExpressions, updateBehavior);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnExpressions, checkConcurrency, updateBehavior);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return Update(dataTable.GetType(), dataTable, columnExpressions, checkConcurrency, updateBehavior);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions, bool checkConcurrency, UpdateBehavior updateBehavior)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnExpressions, checkConcurrency, updateBehavior);
        }
        #endregion

        #region Paging Operation 
        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnExpressions, startRecord, maxRecords);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Type type, System.Data.DataTable dataTable, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).Fill(dataTable, conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnExpressions, startRecord, maxRecords);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, int startRecord, int maxRecords)
        {
            return Fill(dataTable.GetType(), dataTable, columnExpressions, startRecord, maxRecords);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Data.DataTable dataTable, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return Fill(dataTable.GetType(), dataTable, conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return Fill(dataTable.GetType(), dataTable, columnExpressions, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTable(System.Type type, ColumnExpression[] columnExpressions, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).GetData(columnExpressions, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTable(System.Type type, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).GetData(conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTable(System.Type type, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).GetData(columnExpressions, conditionExpression, startRecord, maxRecords);
        }
        #endregion

        #region View Mode
        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetViewData(System.Type type, ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).GetViewData(conditionExpression);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetViewData(System.Type type, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).GetViewData(columnExpressions, conditionExpression);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Type type, System.Data.DataTable dataTable, ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).FillView(dataTable, conditionExpression);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).FillView(dataTable, columnExpressions, conditionExpression);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Data.DataTable dataTable, ConditionExpression conditionExpression)
        {
            return FillView(dataTable.GetType(), dataTable, conditionExpression);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression)
        {
            return FillView(dataTable.GetType(), dataTable, columnExpressions, conditionExpression);
        }

        #region Normal Functions
        /// <summary>
        /// Gets the data row count according the condition.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The count of data rows.</returns>
        public virtual int GetViewDataCount(System.Type type, ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).GetViewDataCount(conditionExpression);
        }

        /// <summary>
        /// Gets the sum of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the sum of data.</returns>
        public virtual object GetViewSumData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).GetViewSumData(columnExpression, conditionExpression);
        }

        /// <summary>
        /// Gets the avg of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the avg of data.</returns>
        public virtual object GetViewAvgData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).GetViewAvgData(columnExpression, conditionExpression);
        }

        /// <summary>
        /// Get the max of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the max of data.</returns>
        public virtual object GetViewMaxData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).GetViewMaxData(columnExpression, conditionExpression);
        }

        /// <summary>
        /// Get the min of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the min of data.</returns>
        public virtual object GetViewMinData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression)
        {
            return GetDataTableAdapter(type).GetViewMinData(columnExpression, conditionExpression);
        }
        #endregion

        #region Paging Operation 
        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetViewData(System.Type type, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).GetViewData(conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetViewData(System.Type type, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).GetViewData(columnExpressions, conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Type type, System.Data.DataTable dataTable, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).FillView(dataTable, conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataTableAdapter(type).FillView(dataTable, columnExpressions, conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Data.DataTable dataTable, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return FillView(dataTable.GetType(), dataTable, conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return FillView(dataTable.GetType(), dataTable, columnExpressions, conditionExpression, startRecord, maxRecords);
        }
        #endregion
        #endregion
        #endregion
        #region Transaction
        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Type type, System.Data.DataTable dataTable, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, conditionExpression, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnExpressions, conditionExpression, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Data.DataTable dataTable, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, conditionExpression, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, columnExpressions, conditionExpression, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillByPrimaryKey(System.Type type, System.Data.DataTable dataTable, object primaryKey, string transactionID)
        {
            return GetDataTableAdapter(type).FillByPrimaryKey(dataTable, primaryKey, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillByPrimaryKey(System.Type type, System.Data.DataTable dataTable, object primaryKey, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataTableAdapter(type).FillByPrimaryKey(dataTable, primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillByPrimaryKey(System.Data.DataTable dataTable, object primaryKey, string transactionID)
        {
            return FillByPrimaryKey(dataTable.GetType(), dataTable, primaryKey, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillByPrimaryKey(System.Data.DataTable dataTable, object primaryKey, ColumnExpression[] columnExpressions, string transactionID)
        {
            return FillByPrimaryKey(dataTable.GetType(), dataTable, primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTable(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTable(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(columnExpressions, conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTableByPrimaryKey(System.Type type, object primaryKey, string transactionID)
        {
            return GetDataTableAdapter(type).GetDataByPrimaryKey(primaryKey, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTableByPrimaryKey(System.Type type, object primaryKey, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataTableAdapter(type).GetDataByPrimaryKey(primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// Delete data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByPrimaryKey(System.Type type, object primaryKey, string transactionID)
        {
            return GetDataTableAdapter(type).DeleteByPrimaryKey(primaryKey, transactionID);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Delete(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).Delete(conditionExpression, transactionID);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="values">values.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateByPrimaryKey(System.Type type, object primaryKey, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).UpdateByPrimaryKey(primaryKey, values, transactionID);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateByPrimaryKey(System.Type type, object primaryKey, ColumnExpression[] columnExpressions, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).UpdateByPrimaryKey(primaryKey, columnExpressions, values, transactionID);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="values">values.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateByPrimaryKey(System.Type type, object primaryKey, Dictionary<string, object> values, string transactionID)
        {
            return GetDataTableAdapter(type).UpdateByPrimaryKey(primaryKey, values, transactionID);
        }

        /// <summary>
        /// Update the data according the condition.
        /// </summary>
        /// <remarks>
        /// Pay attention to the parameter name in the addtion condtion.
        /// </remarks>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="values">values.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(conditionExpression, values, transactionID);
        }

        /// <summary>
        /// Update the data according the condition.
        /// </summary>
        /// <remarks>
        /// Pay attention to the parameter name in the addtion condtion.
        /// </remarks>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, ColumnExpression[] columnExpressions, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(conditionExpression, columnExpressions, values, transactionID);
        }

        /// <summary>
        /// Update the data according the condition.
        /// </summary>
        /// <remarks>
        /// Pay attention to the parameter name in the addtion condtion.
        /// </remarks>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="values">values.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, Dictionary<string, object> values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(conditionExpression, values, transactionID);
        }

        /// <summary>
        /// Check the data by primary key.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>If exists then return true, otherwise return false.</returns>
        public virtual bool ExistsByPrimaryKey(System.Type type, object primaryKey, string transactionID)
        {
            return GetDataTableAdapter(type).ExistsByPrimaryKey(primaryKey, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Type type, System.Data.DataTable dataTable, RaisingStudio.Data.Expressions.ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnExpressions, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Type type, System.Data.DataTable dataTable, object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Data.DataTable dataTable, RaisingStudio.Data.Expressions.ColumnExpression[] columnExpressions, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, columnExpressions, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Data.DataTable dataTable, object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTable(System.Type type, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTable(System.Type type, object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRow">Datarow.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataRow dataRow, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRow, columnExpressions, transactionID);
        }

        /// <summary>
        /// Delete data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="originalValues">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Delete(System.Type type, ColumnExpression[] columnExpressions, object[] originalValues, string transactionID)
        {
            return GetDataTableAdapter(type).Delete(columnExpressions, originalValues, transactionID);
        }

        /// <summary>
        /// Insert data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Insert(System.Type type, ColumnExpression[] columnExpressions, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Insert(columnExpressions, values, transactionID);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, ColumnExpression[] columnExpressions, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(columnExpressions, values, transactionID);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, object[] primaryKeys, ColumnExpression[] columnExpressions, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(primaryKeys, columnExpressions, values, transactionID);
        }

        /// <summary>
        /// Update data.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="originalValues">The original values.</param>
        /// <param name="values">values.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, ColumnExpression[] columnExpressions, object[] originalValues, object[] values, string transactionID)
        {
            return GetDataTableAdapter(type).Update(columnExpressions, originalValues, values, transactionID);
        }

        #region Normal Functions
        /// <summary>
        /// Gets the data row count according the condition.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The count of data rows.</returns>
        public virtual int GetDataCount(System.Type type, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetDataCount(conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the sum of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the sum of data.</returns>
        public virtual object GetSumData(System.Type type, ColumnExpression columnExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetSumData(columnExpression, transactionID);
        }

        /// <summary>
        /// Gets the sum of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the sum of data.</returns>
        public virtual object GetSumData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetSumData(columnExpression, conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the avg of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the avg of data.</returns>
        public virtual object GetAvgData(System.Type type, ColumnExpression columnExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetAvgData(columnExpression, transactionID);
        }

        /// <summary>
        /// Gets the avg of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the avg of data.</returns>
        public virtual object GetAvgData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetAvgData(columnExpression, conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the max of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the max of data.</returns>
        public virtual object GetMaxData(System.Type type, ColumnExpression columnExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetMaxData(columnExpression, transactionID);
        }

        /// <summary>
        /// Get the max of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the max of data.</returns>
        public virtual object GetMaxData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetMaxData(columnExpression, conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the min of data.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <returns>the min of data.</returns>
        public virtual object GetMinData(System.Type type, ColumnExpression columnExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetMinData(columnExpression, transactionID);
        }

        /// <summary>
        /// Get the min of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the min of data.</returns>
        public virtual object GetMinData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetMinData(columnExpression, conditionExpression, transactionID);
        }
        #endregion

        #region 并发冲突及Update 行为
        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, bool checkConcurrency, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnExpressions, checkConcurrency, transactionID);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, bool checkConcurrency, string transactionID)
        {
            return Update(dataTable.GetType(), dataTable, columnExpressions, checkConcurrency, transactionID);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions, bool checkConcurrency, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnExpressions, checkConcurrency, transactionID);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRow">Datarow.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataRow dataRow, ColumnExpression[] columnExpressions, bool checkConcurrency, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRow, columnExpressions, checkConcurrency, transactionID);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, UpdateBehavior updateBehavior, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnExpressions, updateBehavior, transactionID);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(dataTable.GetType(), dataTable, columnExpressions, updateBehavior, transactionID);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions, UpdateBehavior updateBehavior, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnExpressions, updateBehavior, transactionID);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataTable, columnExpressions, checkConcurrency, updateBehavior, transactionID);
        }

        /// <summary>
        /// Update Datatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return Update(dataTable.GetType(), dataTable, columnExpressions, checkConcurrency, updateBehavior, transactionID);
        }

        /// <summary>
        /// Update Datarow.
        /// </summary>
        /// <param name="dataRows">Array of DataRows.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="checkConcurrency">Check concurrency.</param>
        /// <param name="updateBehavior">Update behavior</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataRow[] dataRows, ColumnExpression[] columnExpressions, bool checkConcurrency, UpdateBehavior updateBehavior, string transactionID)
        {
            return GetDataTableAdapter(type).Update(dataRows, columnExpressions, checkConcurrency, updateBehavior, transactionID);
        }
        #endregion

        #region Paging Operation 
        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnExpressions, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Type type, System.Data.DataTable dataTable, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).Fill(dataTable, columnExpressions, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, int startRecord, int maxRecords, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, columnExpressions, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Data.DataTable dataTable, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int Fill(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return Fill(dataTable.GetType(), dataTable, columnExpressions, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTable(System.Type type, ColumnExpression[] columnExpressions, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(columnExpressions, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTable(System.Type type, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetDataTable(System.Type type, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).GetData(columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }
        #endregion

        #region View Mode
        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetViewData(System.Type type, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewData(conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetViewData(System.Type type, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewData(columnExpressions, conditionExpression, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Type type, System.Data.DataTable dataTable, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).FillView(dataTable, conditionExpression, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).FillView(dataTable, columnExpressions, conditionExpression, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Data.DataTable dataTable, ConditionExpression conditionExpression, string transactionID)
        {
            return FillView(dataTable.GetType(), dataTable, conditionExpression, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, string transactionID)
        {
            return FillView(dataTable.GetType(), dataTable, columnExpressions, conditionExpression, transactionID);
        }

        #region Normal Functions
        /// <summary>
        /// Gets the data row count according the condition.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The count of data rows.</returns>
        public virtual int GetViewDataCount(System.Type type, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewDataCount(conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the sum of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the sum of data.</returns>
        public virtual object GetViewSumData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewSumData(columnExpression, conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the avg of data according the condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the avg of data.</returns>
        public virtual object GetViewAvgData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewAvgData(columnExpression, conditionExpression, transactionID);
        }

        /// <summary>
        /// Get the max of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the max of data.</returns>
        public virtual object GetViewMaxData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewMaxData(columnExpression, conditionExpression, transactionID);
        }

        /// <summary>
        /// Get the min of data according condition.
        /// </summary>
        /// <param name="columnExpression">Column expression.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the min of data.</returns>
        public virtual object GetViewMinData(System.Type type, ColumnExpression columnExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewMinData(columnExpression, conditionExpression, transactionID);
        }
        #endregion

        #region Paging Operation 
        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetViewData(System.Type type, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewData(conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets Datatable.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>Datatable.</returns>
        public virtual System.Data.DataTable GetViewData(System.Type type, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).GetViewData(columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Type type, System.Data.DataTable dataTable, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).FillView(dataTable, conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Type type, System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataTableAdapter(type).FillView(dataTable, columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Data.DataTable dataTable, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return FillView(dataTable.GetType(), dataTable, conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// FillDatatable.
        /// </summary>
        /// <param name="dataTable">Datatable.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>The number of rows successfully added to or refreshed. This does not include rows affected by statements that do not return rows.</returns>
        public virtual int FillView(System.Data.DataTable dataTable, ColumnExpression[] columnExpressions, ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return FillView(dataTable.GetType(), dataTable, columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }
        #endregion
        #endregion
        #endregion
        #endregion
        #region DataObject Functions
        #region Common Methods
        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObjectByPrimaryKey(System.Type type, object dataObject, object primaryKey)
        {
            return GetDataObjectAdapter(type).FillByPrimaryKey(dataObject, primaryKey);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObjectByPrimaryKey(System.Type type, object dataObject, object primaryKey, ColumnExpression[] columnExpressions)
        {
            return GetDataObjectAdapter(type).FillByPrimaryKey(dataObject, primaryKey, columnExpressions);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObjectByPrimaryKey(object dataObject, object primaryKey)
        {
            return FillDataObjectByPrimaryKey(dataObject.GetType(), dataObject, primaryKey);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObjectByPrimaryKey(object dataObject, object primaryKey, ColumnExpression[] columnExpressions)
        {
            return FillDataObjectByPrimaryKey(dataObject.GetType(), dataObject, primaryKey, columnExpressions);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>Data object.</returns>
        public virtual object GetDataObjectByPrimaryKey(System.Type type, object primaryKey)
        {
            return GetDataObjectAdapter(type).GetDataByPrimaryKey(primaryKey);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Data object.</returns>
        public virtual object GetDataObjectByPrimaryKey(System.Type type, object primaryKey, ColumnExpression[] columnExpressions)
        {
            return GetDataObjectAdapter(type).GetDataByPrimaryKey(primaryKey, columnExpressions);
        }

        /// <summary>
        /// Delete Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteDataObjectByPrimaryKey(System.Type type, object primaryKey)
        {
            return GetDataObjectAdapter(type).DeleteByPrimaryKey(primaryKey);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObjectByPrimaryKey(System.Type type, object primaryKey, object dataObject)
        {
            return GetDataObjectAdapter(type).UpdateByPrimaryKey(primaryKey, dataObject);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObjectByPrimaryKey(System.Type type, object primaryKey, object dataObject, ColumnExpression[] columnExpressions)
        {
            return GetDataObjectAdapter(type).UpdateByPrimaryKey(primaryKey, dataObject, columnExpressions);
        }

        /// <summary>
        /// Check data object by primary key.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>If exists then return true, otherwise return false.</returns>
        public virtual bool ExistsDataObjectByPrimaryKey(System.Type type, object primaryKey)
        {
            return GetDataObjectAdapter(type).ExistsByPrimaryKey(primaryKey);
        }

        #region Epxression 
        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Data object.</returns>
        public virtual object GetDataObjectByCondition(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataObjectAdapter(type).GetDataByCondition(conditionExpression);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Data object.</returns>
        public virtual object GetDataObjectByCondition(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataObjectAdapter(type).GetDataByCondition(columnExpressions, conditionExpression);
        }

        #region Batch Operation 
        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataObjectAdapter(type).GetDataList(conditionExpression);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataObjectAdapter(type).GetDataList(columnExpressions, conditionExpression);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataObjectAdapter(type).GetDataList(conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataObjectAdapter(type).GetDataList(columnExpressions, conditionExpression, startRecord, maxRecords);
        }
        #endregion

        #region 迭代器
        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataObjectAdapter(type).GetEnumerator(conditionExpression);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnExpressions, conditionExpression);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataObjectAdapter(type).GetEnumerator(conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnExpressions, conditionExpression, startRecord, maxRecords);
        }
        #endregion
        #endregion
        #endregion

        #region column name Epxression 
        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObject(System.Type type, object dataObject, object[] primaryKeys, ColumnExpression[] columnExpressions)
        {
            return GetDataObjectAdapter(type).Fill(dataObject, primaryKeys, columnExpressions);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">has primary key value Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObject(System.Type type, object dataObject, ColumnExpression[] columnExpressions)
        {
            return GetDataObjectAdapter(type).Fill(dataObject, columnExpressions);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObject(object dataObject, object[] primaryKeys, ColumnExpression[] columnExpressions)
        {
            return FillDataObject(dataObject.GetType(), dataObject, primaryKeys, columnExpressions);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">has primary key value Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObject(object dataObject, ColumnExpression[] columnExpressions)
        {
            return FillDataObject(dataObject.GetType(), dataObject, columnExpressions);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Data object.</returns>
        public virtual object GetDataObject(System.Type type, object[] primaryKeys, ColumnExpression[] columnExpressions)
        {
            return GetDataObjectAdapter(type).GetData(primaryKeys, columnExpressions);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="dataObject">has primary key value Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Data object.</returns>
        public virtual object GetDataObject(System.Type type, object dataObject, ColumnExpression[] columnExpressions)
        {
            return GetDataObjectAdapter(type).GetData(dataObject, columnExpressions);
        }

        /// <summary>
        /// Insert Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int InsertDataObject(System.Type type, object dataObject, ColumnExpression[] columnExpressions)
        {
            return GetDataObjectAdapter(type).Insert(dataObject, columnExpressions);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObject(System.Type type, object dataObject, ColumnExpression[] columnExpressions)
        {
            return GetDataObjectAdapter(type).Update(dataObject, columnExpressions);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObject(System.Type type, object[] primaryKeys, object dataObject, ColumnExpression[] columnExpressions)
        {
            return GetDataObjectAdapter(type).Update(primaryKeys, dataObject, columnExpressions);
        }

        /// <summary>
        /// Save Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int SaveDataObject(System.Type type, object dataObject, ColumnExpression[] columnExpressions)
        {
            return GetDataObjectAdapter(type).Save(dataObject, columnExpressions);
        }

        /// <summary>
        /// Insert Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int InsertDataObject(object dataObject, ColumnExpression[] columnExpressions)
        {
            return InsertDataObject(dataObject.GetType(), dataObject, columnExpressions);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObject(object dataObject, ColumnExpression[] columnExpressions)
        {
            return UpdateDataObject(dataObject.GetType(), dataObject, columnExpressions);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObject(object[] primaryKeys, object dataObject, ColumnExpression[] columnExpressions)
        {
            return UpdateDataObject(dataObject.GetType(), primaryKeys, dataObject, columnExpressions);
        }

        /// <summary>
        /// Save Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int SaveDataObject(object dataObject, ColumnExpression[] columnExpressions)
        {
            return SaveDataObject(dataObject.GetType(), dataObject, columnExpressions);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList(System.Type type, ColumnExpression[] columnExpressions)
        {
            return GetDataObjectAdapter(type).GetDataList(columnExpressions);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList(System.Type type, ColumnExpression[] columnExpressions, int startRecord, int maxRecords)
        {
            return GetDataObjectAdapter(type).GetDataList(columnExpressions, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, ColumnExpression[] columnExpressions)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnExpressions);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, ColumnExpression[] columnExpressions, int startRecord, int maxRecords)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnExpressions, startRecord, maxRecords);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObjectByPrimaryKey(object primaryKey, object dataObject, ColumnExpression[] columnExpressions)
        {
            return UpdateDataObjectByPrimaryKey(dataObject.GetType(), primaryKey, dataObject, columnExpressions);
        }
        #endregion
        #endregion
        #endregion
        #region Transaction
        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObjectByPrimaryKey(System.Type type, object dataObject, object primaryKey, string transactionID)
        {
            return GetDataObjectAdapter(type).FillByPrimaryKey(dataObject, primaryKey, transactionID);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObjectByPrimaryKey(System.Type type, object dataObject, object primaryKey, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectAdapter(type).FillByPrimaryKey(dataObject, primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObjectByPrimaryKey(object dataObject, object primaryKey, string transactionID)
        {
            return FillDataObjectByPrimaryKey(dataObject.GetType(), dataObject, primaryKey, transactionID);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObjectByPrimaryKey(object dataObject, object primaryKey, ColumnExpression[] columnExpressions, string transactionID)
        {
            return FillDataObjectByPrimaryKey(dataObject.GetType(), dataObject, primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data object.</returns>
        public virtual object GetDataObjectByPrimaryKey(System.Type type, object primaryKey, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataByPrimaryKey(primaryKey, transactionID);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data object.</returns>
        public virtual object GetDataObjectByPrimaryKey(System.Type type, object primaryKey, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataByPrimaryKey(primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// Delete Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteDataObjectByPrimaryKey(System.Type type, object primaryKey, string transactionID)
        {
            return GetDataObjectAdapter(type).DeleteByPrimaryKey(primaryKey, transactionID);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObjectByPrimaryKey(System.Type type, object primaryKey, object dataObject, string transactionID)
        {
            return GetDataObjectAdapter(type).UpdateByPrimaryKey(primaryKey, dataObject, transactionID);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObjectByPrimaryKey(System.Type type, object primaryKey, object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectAdapter(type).UpdateByPrimaryKey(primaryKey, dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Check data object by primary key.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>If exists then return true, otherwise return false.</returns>
        public virtual bool ExistsDataObjectByPrimaryKey(System.Type type, object primaryKey, string transactionID)
        {
            return GetDataObjectAdapter(type).ExistsByPrimaryKey(primaryKey, transactionID);
        }

        #region Epxression 
        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data object.</returns>
        public virtual object GetDataObjectByCondition(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataByCondition(conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data object.</returns>
        public virtual object GetDataObjectByCondition(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataByCondition(columnExpressions, conditionExpression, transactionID);
        }

        #region Batch Operation 
        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataList(conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataList(columnExpressions, conditionExpression, transactionID);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataList(conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataList(columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }
        #endregion

        #region 迭代器
        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataObjectAdapter(type).GetEnumerator(conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnExpressions, conditionExpression, transactionID);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectAdapter(type).GetEnumerator(conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }
        #endregion
        #endregion
        #endregion

        #region column name Epxression 
        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObject(System.Type type, object dataObject, object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectAdapter(type).Fill(dataObject, primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">has primary key value Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObject(System.Type type, object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectAdapter(type).Fill(dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObject(object dataObject, object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID)
        {
            return FillDataObject(dataObject.GetType(), dataObject, primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// Fill Data object.
        /// </summary>
        /// <param name="dataObject">has primary key value Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataObject(object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return FillDataObject(dataObject.GetType(), dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data object.</returns>
        public virtual object GetDataObject(System.Type type, object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectAdapter(type).GetData(primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Data object.
        /// </summary>
        /// <param name="dataObject">has primary key value Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data object.</returns>
        public virtual object GetDataObject(System.Type type, object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectAdapter(type).GetData(dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Insert Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int InsertDataObject(System.Type type, object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectAdapter(type).Insert(dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObject(System.Type type, object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectAdapter(type).Update(dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObject(System.Type type, object[] primaryKeys, object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectAdapter(type).Update(primaryKeys, dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Save Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int SaveDataObject(System.Type type, object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectAdapter(type).Save(dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Insert Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int InsertDataObject(object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return InsertDataObject(dataObject.GetType(), dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObject(object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return UpdateDataObject(dataObject.GetType(), dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObject(object[] primaryKeys, object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return UpdateDataObject(dataObject.GetType(), primaryKeys, dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Save Data object.
        /// </summary>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int SaveDataObject(object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return SaveDataObject(dataObject.GetType(), dataObject, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList(System.Type type, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataList(columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets data object column table.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>data object column table.</returns>
        public virtual System.Collections.IList GetDataObjectList(System.Type type, ColumnExpression[] columnExpressions, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectAdapter(type).GetDataList(columnExpressions, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataObjectEnumerator(System.Type type, ColumnExpression[] columnExpressions, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataObjectAdapter(type).GetEnumerator(columnExpressions, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Update Data object.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataObject">Data object.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataObjectByPrimaryKey(object primaryKey, object dataObject, ColumnExpression[] columnExpressions, string transactionID)
        {
            return UpdateDataObjectByPrimaryKey(dataObject.GetType(), primaryKey, dataObject, columnExpressions, transactionID);
        }
        #endregion
        #endregion
        #endregion
        #endregion
        #region DataItem Functions 
        #region Common Methods
        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItemByPrimaryKey(System.Type type, RaisingStudio.Data.DataItem dataItem, object primaryKey)
        {
            return GetDataItemAdapter(type).FillByPrimaryKey(dataItem, primaryKey);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItemByPrimaryKey(System.Type type, RaisingStudio.Data.DataItem dataItem, object primaryKey, ColumnExpression[] columnExpressions)
        {
            return GetDataItemAdapter(type).FillByPrimaryKey(dataItem, primaryKey, columnExpressions);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItemByPrimaryKey(RaisingStudio.Data.DataItem dataItem, object primaryKey)
        {
            return FillDataItemByPrimaryKey(dataItem.GetType(), dataItem, primaryKey);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItemByPrimaryKey(RaisingStudio.Data.DataItem dataItem, object primaryKey, ColumnExpression[] columnExpressions)
        {
            return FillDataItemByPrimaryKey(dataItem.GetType(), dataItem, primaryKey, columnExpressions);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItemByPrimaryKey(System.Type type, object primaryKey)
        {
            return GetDataItemAdapter(type).GetDataByPrimaryKey(primaryKey);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItemByPrimaryKey(System.Type type, object primaryKey, ColumnExpression[] columnExpressions)
        {
            return GetDataItemAdapter(type).GetDataByPrimaryKey(primaryKey, columnExpressions);
        }

        /// <summary>
        /// Delete Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteDataItemByPrimaryKey(System.Type type, object primaryKey)
        {
            return GetDataItemAdapter(type).DeleteByPrimaryKey(primaryKey);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItemByPrimaryKey(System.Type type, object primaryKey, RaisingStudio.Data.DataItem dataItem)
        {
            return GetDataItemAdapter(type).UpdateByPrimaryKey(primaryKey, dataItem);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItemByPrimaryKey(System.Type type, object primaryKey, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return GetDataItemAdapter(type).UpdateByPrimaryKey(primaryKey, dataItem, columnExpressions);
        }

        /// <summary>
        /// Check the data item exists or not.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>If exists then return true, otherwise return false.</returns>
        public virtual bool ExistsDataItemByPrimaryKey(System.Type type, object primaryKey)
        {
            return GetDataItemAdapter(type).ExistsByPrimaryKey(primaryKey);
        }

        #region Epxression 
        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItemByCondition(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataItemAdapter(type).GetDataByCondition(conditionExpression);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItemByCondition(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataItemAdapter(type).GetDataByCondition(columnExpressions, conditionExpression);
        }

        #region Batch Operation 
        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataItemAdapter(type).GetDataList(conditionExpression);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataItemAdapter(type).GetDataList(columnExpressions, conditionExpression);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataItemAdapter(type).GetDataList(conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataItemAdapter(type).GetDataList(columnExpressions, conditionExpression, startRecord, maxRecords);
        }
        #endregion

        #region 迭代器
        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataItemAdapter(type).GetEnumerator(conditionExpression);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnExpressions, conditionExpression);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataItemAdapter(type).GetEnumerator(conditionExpression, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnExpressions, conditionExpression, startRecord, maxRecords);
        }
        #endregion
        #endregion
        #endregion

        #region column name Epxression 
        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItem(System.Type type, RaisingStudio.Data.DataItem dataItem, object[] primaryKeys, ColumnExpression[] columnExpressions)
        {
            return GetDataItemAdapter(type).Fill(dataItem, primaryKeys, columnExpressions);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item that contains primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItem(System.Type type, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return GetDataItemAdapter(type).Fill(dataItem, columnExpressions);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItem(RaisingStudio.Data.DataItem dataItem, object[] primaryKeys, ColumnExpression[] columnExpressions)
        {
            return FillDataItem(dataItem.GetType(), dataItem, primaryKeys, columnExpressions);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item that contains primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItem(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return FillDataItem(dataItem.GetType(), dataItem, columnExpressions);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItem(System.Type type, object[] primaryKeys, ColumnExpression[] columnExpressions)
        {
            return GetDataItemAdapter(type).GetData(primaryKeys, columnExpressions);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="dataItem">Data item that contains primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItem(System.Type type, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return GetDataItemAdapter(type).GetData(dataItem, columnExpressions);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="dataItem">Data item that contains primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItem(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return GetDataItem(dataItem.GetType(), dataItem, columnExpressions);
        }

        /// <summary>
        /// Insert Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int InsertDataItem(System.Type type, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return GetDataItemAdapter(type).Insert(dataItem, columnExpressions);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItem(System.Type type, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return GetDataItemAdapter(type).Update(dataItem, columnExpressions);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItem(System.Type type, object[] primaryKeys, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return GetDataItemAdapter(type).Update(primaryKeys, dataItem, columnExpressions);
        }

        /// <summary>
        /// Save Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int SaveDataItem(System.Type type, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return GetDataItemAdapter(type).Save(dataItem, columnExpressions);
        }

        /// <summary>
        /// Insert Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int InsertDataItem(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return InsertDataItem(dataItem.GetType(), dataItem, columnExpressions);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItem(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return UpdateDataItem(dataItem.GetType(), dataItem, columnExpressions);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItem(object[] primaryKeys, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return UpdateDataItem(dataItem.GetType(), primaryKeys, dataItem, columnExpressions);
        }

        /// <summary>
        /// Save Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int SaveDataItem(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return SaveDataItem(dataItem.GetType(), dataItem, columnExpressions);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList(System.Type type, ColumnExpression[] columnExpressions)
        {
            return GetDataItemAdapter(type).GetDataList(columnExpressions);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList(System.Type type, ColumnExpression[] columnExpressions, int startRecord, int maxRecords)
        {
            return GetDataItemAdapter(type).GetDataList(columnExpressions, startRecord, maxRecords);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, ColumnExpression[] columnExpressions)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnExpressions);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, ColumnExpression[] columnExpressions, int startRecord, int maxRecords)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnExpressions, startRecord, maxRecords);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItemByPrimaryKey(object primaryKey, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions)
        {
            return UpdateDataItemByPrimaryKey(dataItem.GetType(), primaryKey, dataItem, columnExpressions);
        }
        #endregion
        #endregion
        #endregion
        #region Transaction
        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItemByPrimaryKey(System.Type type, RaisingStudio.Data.DataItem dataItem, object primaryKey, string transactionID)
        {
            return GetDataItemAdapter(type).FillByPrimaryKey(dataItem, primaryKey, transactionID);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItemByPrimaryKey(System.Type type, RaisingStudio.Data.DataItem dataItem, object primaryKey, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemAdapter(type).FillByPrimaryKey(dataItem, primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItemByPrimaryKey(RaisingStudio.Data.DataItem dataItem, object primaryKey, string transactionID)
        {
            return FillDataItemByPrimaryKey(dataItem.GetType(), dataItem, primaryKey, transactionID);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItemByPrimaryKey(RaisingStudio.Data.DataItem dataItem, object primaryKey, ColumnExpression[] columnExpressions, string transactionID)
        {
            return FillDataItemByPrimaryKey(dataItem.GetType(), dataItem, primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItemByPrimaryKey(System.Type type, object primaryKey, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataByPrimaryKey(primaryKey, transactionID);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItemByPrimaryKey(System.Type type, object primaryKey, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataByPrimaryKey(primaryKey, columnExpressions, transactionID);
        }

        /// <summary>
        /// Delete Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteDataItemByPrimaryKey(System.Type type, object primaryKey, string transactionID)
        {
            return GetDataItemAdapter(type).DeleteByPrimaryKey(primaryKey, transactionID);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItemByPrimaryKey(System.Type type, object primaryKey, RaisingStudio.Data.DataItem dataItem, string transactionID)
        {
            return GetDataItemAdapter(type).UpdateByPrimaryKey(primaryKey, dataItem, transactionID);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItemByPrimaryKey(System.Type type, object primaryKey, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemAdapter(type).UpdateByPrimaryKey(primaryKey, dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Check the data item exists or not.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>If exists then return true, otherwise return false.</returns>
        public virtual bool ExistsDataItemByPrimaryKey(System.Type type, object primaryKey, string transactionID)
        {
            return GetDataItemAdapter(type).ExistsByPrimaryKey(primaryKey, transactionID);
        }

        #region Epxression 
        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItemByCondition(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataByCondition(conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItemByCondition(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataByCondition(columnExpressions, conditionExpression, transactionID);
        }

        #region Batch Operation 
        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataList(conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataList(columnExpressions, conditionExpression, transactionID);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataList(conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataList(columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }
        #endregion

        #region 迭代器
        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataItemAdapter(type).GetEnumerator(conditionExpression, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnExpressions, conditionExpression, transactionID);
        }

        #region Paging Operation 
        /// <summary>
        /// Gets the enumerator of data objects.
        /// </summary>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data objects.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemAdapter(type).GetEnumerator(conditionExpression, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, ColumnExpression[] columnExpressions, RaisingStudio.Data.Expressions.ConditionExpression conditionExpression, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnExpressions, conditionExpression, startRecord, maxRecords, transactionID);
        }
        #endregion
        #endregion
        #endregion

        #region column name Epxression 
        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItem(System.Type type, RaisingStudio.Data.DataItem dataItem, object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemAdapter(type).Fill(dataItem, primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item that contains primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItem(System.Type type, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemAdapter(type).Fill(dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItem(RaisingStudio.Data.DataItem dataItem, object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID)
        {
            return FillDataItem(dataItem.GetType(), dataItem, primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// FillData item.
        /// </summary>
        /// <param name="dataItem">Data item that contains primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The result of execute command.</returns>
        public virtual int FillDataItem(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return FillDataItem(dataItem.GetType(), dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItem(System.Type type, object[] primaryKeys, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemAdapter(type).GetData(primaryKeys, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="dataItem">Data item that contains primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItem(System.Type type, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemAdapter(type).GetData(dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets Data item.
        /// </summary>
        /// <param name="dataItem">Data item that contains primary key.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>Data item.</returns>
        public virtual RaisingStudio.Data.DataItem GetDataItem(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItem(dataItem.GetType(), dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Insert Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int InsertDataItem(System.Type type, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemAdapter(type).Insert(dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItem(System.Type type, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemAdapter(type).Update(dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItem(System.Type type, object[] primaryKeys, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemAdapter(type).Update(primaryKeys, dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Save Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int SaveDataItem(System.Type type, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemAdapter(type).Save(dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Insert Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int InsertDataItem(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return InsertDataItem(dataItem.GetType(), dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItem(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return UpdateDataItem(dataItem.GetType(), dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItem(object[] primaryKeys, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return UpdateDataItem(dataItem.GetType(), primaryKeys, dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Save Data item.
        /// </summary>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int SaveDataItem(RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return SaveDataItem(dataItem.GetType(), dataItem, columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList(System.Type type, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataList(columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets the list of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the list of data items.</returns>
        public virtual System.Collections.IList GetDataItemList(System.Type type, ColumnExpression[] columnExpressions, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemAdapter(type).GetDataList(columnExpressions, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, ColumnExpression[] columnExpressions, string transactionID)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnExpressions, transactionID);
        }

        /// <summary>
        /// Gets the enumerator of data items.
        /// </summary>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="startRecord">The zero-based record number to start with. </param>
        /// <param name="maxRecords">The maximum number of records to retrieve. </param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>the enumerator of data items.</returns>
        public virtual System.Collections.IEnumerable GetDataItemEnumerator(System.Type type, ColumnExpression[] columnExpressions, int startRecord, int maxRecords, string transactionID)
        {
            return GetDataItemAdapter(type).GetEnumerator(columnExpressions, startRecord, maxRecords, transactionID);
        }

        /// <summary>
        /// Update Data item.
        /// </summary>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="dataItem">Data item.</param>
        /// <param name="columnExpressions">An array of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int UpdateDataItemByPrimaryKey(object primaryKey, RaisingStudio.Data.DataItem dataItem, ColumnExpression[] columnExpressions, string transactionID)
        {
            return UpdateDataItemByPrimaryKey(dataItem.GetType(), primaryKey, dataItem, columnExpressions, transactionID);
        }
        #endregion
        #endregion
        #endregion
        #endregion
        #region DataSet Functions
        #region Common Methods
        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <returns>dataset.</returns>
        public virtual System.Data.DataSet GetDataSet(System.Type type, TableExpression[] tableExpressions)
        {
            return GetDataSetAdapter(type).GetData(tableExpressions);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill(System.Type type, System.Data.DataSet dataSet, TableExpression[] tableExpressions)
        {
            return GetDataSetAdapter(type).Fill(dataSet, tableExpressions);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataSet dataSet, TableExpression[] tableExpressions)
        {
            return GetDataSetAdapter(type).Update(dataSet, tableExpressions);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill(System.Data.DataSet dataSet, TableExpression[] tableExpressions)
        {
            return Fill(dataSet.GetType(), dataSet, tableExpressions);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Data.DataSet dataSet, TableExpression[] tableExpressions)
        {
            return Update(dataSet.GetType(), dataSet, tableExpressions);
        }


        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>dataset.</returns>
        public virtual System.Data.DataSet GetDataSet(System.Type type, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary)
        {
            return GetDataSetAdapter(type).GetData(columnExpressionsDictionary);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill(System.Type type, System.Data.DataSet dataSet, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary)
        {
            return GetDataSetAdapter(type).Fill(dataSet, columnExpressionsDictionary);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataSet dataSet, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary)
        {
            return GetDataSetAdapter(type).Update(dataSet, columnExpressionsDictionary);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill(System.Data.DataSet dataSet, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary)
        {
            return Fill(dataSet.GetType(), dataSet, columnExpressionsDictionary);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Data.DataSet dataSet, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary)
        {
            return Update(dataSet.GetType(), dataSet, columnExpressionsDictionary);
        }


        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>dataset.</returns>
        public virtual System.Data.DataSet GetDataSet(System.Type type, TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary)
        {
            return GetDataSetAdapter(type).GetData(tableExpressions, columnExpressionsDictionary);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill(System.Type type, System.Data.DataSet dataSet, TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary)
        {
            return GetDataSetAdapter(type).Fill(dataSet, tableExpressions, columnExpressionsDictionary);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataSet dataSet, TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary)
        {
            return GetDataSetAdapter(type).Update(dataSet, tableExpressions, columnExpressionsDictionary);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill(System.Data.DataSet dataSet, TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary)
        {
            return Fill(dataSet.GetType(), dataSet, tableExpressions, columnExpressionsDictionary);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Data.DataSet dataSet, TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary)
        {
            return Update(dataSet.GetType(), dataSet, tableExpressions, columnExpressionsDictionary);
        }


        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <returns>dataset.</returns>
        public virtual System.Data.DataSet GetDataByRelation(System.Type type, RaisingStudio.Data.Expressions.TableExpression tableExpression, object[] primaryKeys, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode)
        {
            return GetDataSetAdapter(type).GetDataByRelation(tableExpression, primaryKeys, columnExpressionsDictionary, viewMode);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelation(System.Type type, System.Data.DataSet dataSet, TableExpression tableExpression, object[] primaryKeys, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode)
        {
            return GetDataSetAdapter(type).FillByRelation(dataSet, tableExpression, primaryKeys, columnExpressionsDictionary, viewMode);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelationByPrimaryKey(System.Type type, System.Data.DataSet dataSet, TableExpression tableExpression, object primaryKey, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode)
        {
            return GetDataSetAdapter(type).FillByRelationByPrimaryKey(dataSet, tableExpression, primaryKey, columnExpressionsDictionary, viewMode);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelation(System.Data.DataSet dataSet, TableExpression tableExpression, object[] primaryKeys, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode)
        {
            return FillByRelation(dataSet.GetType(), dataSet, tableExpression, primaryKeys, columnExpressionsDictionary, viewMode);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelationByPrimaryKey(System.Data.DataSet dataSet, TableExpression tableExpression, object primaryKey, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode)
        {
            return FillByRelationByPrimaryKey(dataSet.GetType(), dataSet, tableExpression, primaryKey, columnExpressionsDictionary, viewMode);
        }

        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="viewMode">view mode.</param>
        /// <returns>dataset.</returns>
        public virtual System.Data.DataSet GetDataByRelation(System.Type type, TableExpression tableExpression, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, ConditionExpression conditionExpression, bool viewMode)
        {
            return GetDataSetAdapter(type).GetDataByRelation(tableExpression, columnExpressionsDictionary, conditionExpression, viewMode);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="viewMode">view mode.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelation(System.Type type, System.Data.DataSet dataSet, TableExpression tableExpression, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, ConditionExpression conditionExpression, bool viewMode)
        {
            return GetDataSetAdapter(type).FillByRelation(dataSet, tableExpression, columnExpressionsDictionary, conditionExpression, viewMode);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="viewMode">view mode.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelation(System.Data.DataSet dataSet, TableExpression tableExpression, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, ConditionExpression conditionExpression, bool viewMode)
        {
            return FillByRelation(dataSet.GetType(), dataSet, tableExpression, columnExpressionsDictionary, conditionExpression, viewMode);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByRelation(System.Type type, TableExpression tableExpression, object[] primaryKeys)
        {
            return GetDataSetAdapter(type).DeleteByRelation(tableExpression, primaryKeys);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByRelationByPrimaryKey(System.Type type, TableExpression tableExpression, object primaryKey)
        {
            return GetDataSetAdapter(type).DeleteByRelationByPrimaryKey(tableExpression, primaryKey);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByRelation(System.Type type, TableExpression tableExpression, ConditionExpression conditionExpression)
        {
            return GetDataSetAdapter(type).DeleteByRelation(tableExpression, conditionExpression);
        }
        #endregion
        #region Transaction
        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>dataset.</returns>
        public virtual System.Data.DataSet GetDataSet(System.Type type, TableExpression[] tableExpressions, string transactionID)
        {
            return GetDataSetAdapter(type).GetData(tableExpressions, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill(System.Type type, System.Data.DataSet dataSet, TableExpression[] tableExpressions, string transactionID)
        {
            return GetDataSetAdapter(type).Fill(dataSet, tableExpressions, transactionID);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataSet dataSet, TableExpression[] tableExpressions, string transactionID)
        {
            return GetDataSetAdapter(type).Update(dataSet, tableExpressions, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill(System.Data.DataSet dataSet, TableExpression[] tableExpressions, string transactionID)
        {
            return Fill(dataSet.GetType(), dataSet, tableExpressions, transactionID);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Data.DataSet dataSet, TableExpression[] tableExpressions, string transactionID)
        {
            return Update(dataSet.GetType(), dataSet, tableExpressions, transactionID);
        }


        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>dataset.</returns>
        public virtual System.Data.DataSet GetDataSet(System.Type type, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID)
        {
            return GetDataSetAdapter(type).GetData(columnExpressionsDictionary, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill(System.Type type, System.Data.DataSet dataSet, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID)
        {
            return GetDataSetAdapter(type).Fill(dataSet, columnExpressionsDictionary, transactionID);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataSet dataSet, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID)
        {
            return GetDataSetAdapter(type).Update(dataSet, columnExpressionsDictionary, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill(System.Data.DataSet dataSet, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID)
        {
            return Fill(dataSet.GetType(), dataSet, columnExpressionsDictionary, transactionID);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Data.DataSet dataSet, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID)
        {
            return Update(dataSet.GetType(), dataSet, columnExpressionsDictionary, transactionID);
        }


        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>dataset.</returns>
        public virtual System.Data.DataSet GetDataSet(System.Type type, TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID)
        {
            return GetDataSetAdapter(type).GetData(tableExpressions, columnExpressionsDictionary, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill(System.Type type, System.Data.DataSet dataSet, TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID)
        {
            return GetDataSetAdapter(type).Fill(dataSet, tableExpressions, columnExpressionsDictionary, transactionID);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Type type, System.Data.DataSet dataSet, TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID)
        {
            return GetDataSetAdapter(type).Update(dataSet, tableExpressions, columnExpressionsDictionary, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int Fill(System.Data.DataSet dataSet, TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID)
        {
            return Fill(dataSet.GetType(), dataSet, tableExpressions, columnExpressionsDictionary, transactionID);
        }

        /// <summary>
        /// Update dataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpressions">An array of table expression.</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int Update(System.Data.DataSet dataSet, TableExpression[] tableExpressions, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, string transactionID)
        {
            return Update(dataSet.GetType(), dataSet, tableExpressions, columnExpressionsDictionary, transactionID);
        }


        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>dataset.</returns>
        public virtual System.Data.DataSet GetDataByRelation(System.Type type, RaisingStudio.Data.Expressions.TableExpression tableExpression, object[] primaryKeys, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode, string transactionID)
        {
            return GetDataSetAdapter(type).GetDataByRelation(tableExpression, primaryKeys, columnExpressionsDictionary, viewMode, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelation(System.Type type, System.Data.DataSet dataSet, TableExpression tableExpression, object[] primaryKeys, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode, string transactionID)
        {
            return GetDataSetAdapter(type).FillByRelation(dataSet, tableExpression, primaryKeys, columnExpressionsDictionary, viewMode, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelationByPrimaryKey(System.Type type, System.Data.DataSet dataSet, TableExpression tableExpression, object primaryKey, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode, string transactionID)
        {
            return GetDataSetAdapter(type).FillByRelationByPrimaryKey(dataSet, tableExpression, primaryKey, columnExpressionsDictionary, viewMode, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelation(System.Data.DataSet dataSet, TableExpression tableExpression, object[] primaryKeys, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode, string transactionID)
        {
            return FillByRelation(dataSet.GetType(), dataSet, tableExpression, primaryKeys, columnExpressionsDictionary, viewMode, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="viewMode">view mode.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelationByPrimaryKey(System.Data.DataSet dataSet, TableExpression tableExpression, object primaryKey, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, bool viewMode, string transactionID)
        {
            return FillByRelationByPrimaryKey(dataSet.GetType(), dataSet, tableExpression, primaryKey, columnExpressionsDictionary, viewMode, transactionID);
        }

        /// <summary>
        /// Gets dataset.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="viewMode">view mode.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>dataset.</returns>
        public virtual System.Data.DataSet GetDataByRelation(System.Type type, TableExpression tableExpression, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, ConditionExpression conditionExpression, bool viewMode, string transactionID)
        {
            return GetDataSetAdapter(type).GetDataByRelation(tableExpression, columnExpressionsDictionary, conditionExpression, viewMode, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="viewMode">view mode.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelation(System.Type type, System.Data.DataSet dataSet, TableExpression tableExpression, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, ConditionExpression conditionExpression, bool viewMode, string transactionID)
        {
            return GetDataSetAdapter(type).FillByRelation(dataSet, tableExpression, columnExpressionsDictionary, conditionExpression, viewMode, transactionID);
        }

        /// <summary>
        /// FillDataset.
        /// </summary>
        /// <param name="dataSet">dataset.</param>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="columnExpressionsDictionary">dictionary of column expressions.</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="viewMode">view mode.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The number of rows successfully added to or refreshed in the DataSet. This does not include rows affected by statements that do not return rows. </returns>
        public virtual int FillByRelation(System.Data.DataSet dataSet, TableExpression tableExpression, Dictionary<RaisingStudio.Data.Expressions.TableExpression, RaisingStudio.Data.Expressions.ColumnExpression[]> columnExpressionsDictionary, ConditionExpression conditionExpression, bool viewMode, string transactionID)
        {
            return FillByRelation(dataSet.GetType(), dataSet, tableExpression, columnExpressionsDictionary, conditionExpression, viewMode, transactionID);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="primaryKeys">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByRelation(System.Type type, TableExpression tableExpression, object[] primaryKeys, string transactionID)
        {
            return GetDataSetAdapter(type).DeleteByRelation(tableExpression, primaryKeys, transactionID);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="primaryKey">The value of primary key.</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByRelationByPrimaryKey(System.Type type, TableExpression tableExpression, object primaryKey, string transactionID)
        {
            return GetDataSetAdapter(type).DeleteByRelationByPrimaryKey(tableExpression, primaryKey, transactionID);
        }

        /// <summary>
        /// Delete the data according the condition.
        /// </summary>
        /// <param name="tableExpression">table name expression</param>
        /// <param name="conditionExpression">Condition expression</param>
        /// <param name="transactionID">The ID of transaction.</param>
        /// <returns>The count of rows that updated.</returns>
        public virtual int DeleteByRelation(System.Type type, TableExpression tableExpression, ConditionExpression conditionExpression, string transactionID)
        {
            return GetDataSetAdapter(type).DeleteByRelation(tableExpression, conditionExpression, transactionID);
        }
        #endregion
        #endregion
        #endregion
    }
}
